Refactord BasicTests

ngruson · ngruson · commit a60a8f52ec3c · 2023-11-11T17:43:55.000+01:00
diff --git a/test/OpenTelemetry.Instrumentation.AspNetCore.Tests/BasicTests.cs b/test/OpenTelemetry.Instrumentation.AspNetCore.Tests/BasicTests.cs
@@ -845,7 +845,8 @@ public async Task ShouldExportActivityWithOneOrMoreExceptionFilters(int mode)
     public async Task DiagnosticSourceCallbacksAreReceivedOnlyForSubscribedEvents()
     {
         int numberOfUnSubscribedEvents = 0;
-        int numberofSubscribedEvents = 0;
+        int numberOfSubscribedEvents = 0;
+
         void ConfigureTestServices(IServiceCollection services)
         {
             this.tracerProvider = Sdk.CreateTracerProviderBuilder()
@@ -858,19 +859,19 @@ void ConfigureTestServices(IServiceCollection services)
                             {
                                 case HttpInListener.OnStartEvent:
                                     {
-                                        numberofSubscribedEvents++;
+                                        numberOfSubscribedEvents++;
                                     }
 
                                     break;
                                 case HttpInListener.OnStopEvent:
                                     {
-                                        numberofSubscribedEvents++;
+                                        numberOfSubscribedEvents++;
                                     }
 
                                     break;
                                 case HttpInListener.OnMvcBeforeActionEvent:
                                     {
-                                        numberofSubscribedEvents++;
+                                        numberOfSubscribedEvents++;
                                     }
 
                                     break;
@@ -884,6 +885,10 @@ void ConfigureTestServices(IServiceCollection services)
                         },
                     })
                 .Build();
+
+            services.AddOpenTelemetry()
+                .WithTracing(builder => builder
+                    .AddInstrumentation(() => this.tracerProvider));
         }
 
         // Arrange
@@ -902,15 +907,16 @@ void ConfigureTestServices(IServiceCollection services)
         }
 
         Assert.Equal(0, numberOfUnSubscribedEvents);
-        Assert.Equal(3, numberofSubscribedEvents);
+        Assert.Equal(3, numberOfSubscribedEvents);
     }
 
     [Fact]
     public async Task DiagnosticSourceExceptionCallbackIsReceivedForUnHandledException()
     {
         int numberOfUnSubscribedEvents = 0;
-        int numberofSubscribedEvents = 0;
+        int numberOfSubscribedEvents = 0;
         int numberOfExceptionCallbacks = 0;
+
         void ConfigureTestServices(IServiceCollection services)
         {
             this.tracerProvider = Sdk.CreateTracerProviderBuilder()
@@ -923,19 +929,19 @@ void ConfigureTestServices(IServiceCollection services)
                             {
                                 case HttpInListener.OnStartEvent:
                                     {
-                                        numberofSubscribedEvents++;
+                                        numberOfSubscribedEvents++;
                                     }
 
                                     break;
                                 case HttpInListener.OnStopEvent:
                                     {
-                                        numberofSubscribedEvents++;
+                                        numberOfSubscribedEvents++;
                                     }
 
                                     break;
                                 case HttpInListener.OnMvcBeforeActionEvent:
                                     {
-                                        numberofSubscribedEvents++;
+                                        numberOfSubscribedEvents++;
                                     }
 
                                     break;
@@ -945,7 +951,7 @@ void ConfigureTestServices(IServiceCollection services)
                                 case HttpInListener.OnUnhandledHostingExceptionEvent:
                                 case HttpInListener.OnUnHandledDiagnosticsExceptionEvent:
                                     {
-                                        numberofSubscribedEvents++;
+                                        numberOfSubscribedEvents++;
                                         numberOfExceptionCallbacks++;
                                     }
 
@@ -960,6 +966,10 @@ void ConfigureTestServices(IServiceCollection services)
                         },
                     })
                 .Build();
+
+            services.AddOpenTelemetry()
+                .WithTracing(builder => builder
+                    .AddInstrumentation(() => this.tracerProvider));
         }
 
         // Arrange
@@ -986,18 +996,20 @@ void ConfigureTestServices(IServiceCollection services)
 
         Assert.Equal(1, numberOfExceptionCallbacks);
         Assert.Equal(0, numberOfUnSubscribedEvents);
-        Assert.Equal(4, numberofSubscribedEvents);
+        Assert.Equal(4, numberOfSubscribedEvents);
     }
 
     [Fact(Skip = "https://github.com/open-telemetry/opentelemetry-dotnet/issues/4884")]
     public async Task DiagnosticSourceExceptionCallBackIsNotReceivedForExceptionsHandledInMiddleware()
     {
         int numberOfUnSubscribedEvents = 0;
-        int numberofSubscribedEvents = 0;
+        int numberOfSubscribedEvents = 0;
         int numberOfExceptionCallbacks = 0;
 
-        // configure SDK
-        using var tracerprovider = Sdk.CreateTracerProviderBuilder()
+        void ConfigureTestServices(IServiceCollection services)
+        {
+            // configure SDK
+            this.tracerProvider = Sdk.CreateTracerProviderBuilder()
             .AddAspNetCoreInstrumentation(
                 new TestHttpInListener(new AspNetCoreInstrumentationOptions())
                 {
@@ -1007,13 +1019,13 @@ public async Task DiagnosticSourceExceptionCallBackIsNotReceivedForExceptionsHan
                         {
                             case HttpInListener.OnStartEvent:
                                 {
-                                    numberofSubscribedEvents++;
+                                    numberOfSubscribedEvents++;
                                 }
 
                                 break;
                             case HttpInListener.OnStopEvent:
                                 {
-                                    numberofSubscribedEvents++;
+                                    numberOfSubscribedEvents++;
                                 }
 
                                 break;
@@ -1023,7 +1035,7 @@ public async Task DiagnosticSourceExceptionCallBackIsNotReceivedForExceptionsHan
                             case HttpInListener.OnUnhandledHostingExceptionEvent:
                             case HttpInListener.OnUnHandledDiagnosticsExceptionEvent:
                                 {
-                                    numberofSubscribedEvents++;
+                                    numberOfSubscribedEvents++;
                                     numberOfExceptionCallbacks++;
                                 }
 
@@ -1039,45 +1051,43 @@ public async Task DiagnosticSourceExceptionCallBackIsNotReceivedForExceptionsHan
                 })
                 .Build();
 
-        var builder = WebApplication.CreateBuilder();
-        builder.Logging.ClearProviders();
-        var app = builder.Build();
+            services.AddOpenTelemetry()
+                .WithTracing(builder => builder
+                    .AddInstrumentation(() => this.tracerProvider));
+        }
 
-        app.UseExceptionHandler(handler =>
-        {
-            handler.Run(async (ctx) =>
+        using (var client = this.factory
+            .WithWebHostBuilder(builder =>
             {
-                await ctx.Response.WriteAsync("handled").ConfigureAwait(false);
-            });
-        });
-
-        app.Map("/error", ThrowException);
-
-        static void ThrowException(IApplicationBuilder app)
+                builder.ConfigureTestServices(ConfigureTestServices);
+                builder.ConfigureLogging(loggingBuilder => loggingBuilder.ClearProviders());
+                builder.Configure(app => app
+                    .UseExceptionHandler(handler =>
+                    {
+                        handler.Run(async (ctx) =>
+                        {
+                            await ctx.Response.WriteAsync("handled").ConfigureAwait(false);
+                        });
+                    }));
+            })
+            .CreateClient())
         {
-            app.Run(context =>
+            try
             {
-                throw new Exception("CustomException");
-            });
-        }
-
-        _ = app.RunAsync();
+                using var request = new HttpRequestMessage(HttpMethod.Get, "/api/error");
 
-        using var client = new HttpClient();
-        try
-        {
-            await client.GetStringAsync("http://localhost:5000/error").ConfigureAwait(false);
-        }
-        catch
-        {
-            // ignore 500 error.
+                // Act
+                using var response = await client.SendAsync(request).ConfigureAwait(false);
+            }
+            catch
+            {
+                // ignore exception
+            }
         }
 
         Assert.Equal(0, numberOfExceptionCallbacks);
         Assert.Equal(0, numberOfUnSubscribedEvents);
-        Assert.Equal(2, numberofSubscribedEvents);
-
-        await app.DisposeAsync().ConfigureAwait(false);
+        Assert.Equal(2, numberOfSubscribedEvents);
     }
 
     [Fact]
@@ -1093,8 +1103,6 @@ void ConfigureTestServices(IServiceCollection services)
                 .AddInMemoryExporter(exportedItems)
                 .Build();
 
-            var meterFactory = this.factory.Services.GetRequiredService<IMeterFactory>();
-            services.AddSingleton(meterFactory);
             services.AddRouting();
             services.AddOpenTelemetry()
                 .WithTracing(builder =>
@@ -1220,16 +1228,10 @@ private void ConfigureExceptionFilters(IServiceCollection services, int mode, re
             .Build();
     }
 
-    private class ExtractOnlyPropagator : TextMapPropagator
+    private class ExtractOnlyPropagator(ActivityContext activityContext, Baggage baggage) : TextMapPropagator
     {
-        private readonly ActivityContext activityContext;
-        private readonly Baggage baggage;
-
-        public ExtractOnlyPropagator(ActivityContext activityContext, Baggage baggage)
-        {
-            this.activityContext = activityContext;
-            this.baggage = baggage;
-        }
+        private readonly ActivityContext activityContext = activityContext;
+        private readonly Baggage baggage = baggage;
 
         public override ISet<string> Fields => throw new NotImplementedException();
 
@@ -1244,32 +1246,21 @@ public override void Inject<T>(PropagationContext context, T carrier, Action<T,
         }
     }
 
-    private class TestSampler : Sampler
+    private class TestSampler(SamplingDecision samplingDecision, IEnumerable<KeyValuePair<string, object>> attributes = null) : Sampler
     {
-        private readonly SamplingDecision samplingDecision;
-        private readonly IEnumerable<KeyValuePair<string, object>> attributes;
-
-        public TestSampler(SamplingDecision samplingDecision, IEnumerable<KeyValuePair<string, object>> attributes = null)
-        {
-            this.samplingDecision = samplingDecision;
-            this.attributes = attributes;
-        }
+        private readonly SamplingDecision samplingDecision = samplingDecision;
+        private readonly IEnumerable<KeyValuePair<string, object>> attributes = attributes;
 
         public override SamplingResult ShouldSample(in SamplingParameters samplingParameters)
         {
             return new SamplingResult(this.samplingDecision, this.attributes);
         }
     }
 
-    private class TestHttpInListener : HttpInListener
+    private class TestHttpInListener(AspNetCoreInstrumentationOptions options) : HttpInListener(options)
     {
         public Action<string, object> OnEventWrittenCallback;
 
-        public TestHttpInListener(AspNetCoreInstrumentationOptions options)
-            : base(options)
-        {
-        }
-
         public override void OnEventWritten(string name, object payload)
         {
             base.OnEventWritten(name, payload);
@@ -1278,17 +1269,11 @@ public override void OnEventWritten(string name, object payload)
         }
     }
 
-    private class TestNullHostActivityMiddlewareImpl : ActivityMiddleware.ActivityMiddlewareImpl
+    private class TestNullHostActivityMiddlewareImpl(string activitySourceName, string activityName) : ActivityMiddleware.ActivityMiddlewareImpl
     {
-        private ActivitySource activitySource;
+        private readonly ActivitySource activitySource = new(activitySourceName);
+        private readonly string activityName = activityName;
         private Activity activity;
-        private string activityName;
-
-        public TestNullHostActivityMiddlewareImpl(string activitySourceName, string activityName)
-        {
-            this.activitySource = new ActivitySource(activitySourceName);
-            this.activityName = activityName;
-        }
 
         public override void PreProcess(HttpContext context)
         {
@@ -1306,17 +1291,11 @@ public override void PostProcess(HttpContext context)
         }
     }
 
-    private class TestActivityMiddlewareImpl : ActivityMiddleware.ActivityMiddlewareImpl
+    private class TestActivityMiddlewareImpl(string activitySourceName, string activityName) : ActivityMiddleware.ActivityMiddlewareImpl
     {
-        private ActivitySource activitySource;
+        private readonly ActivitySource activitySource = new(activitySourceName);
+        private readonly string activityName = activityName;
         private Activity activity;
-        private string activityName;
-
-        public TestActivityMiddlewareImpl(string activitySourceName, string activityName)
-        {
-            this.activitySource = new ActivitySource(activitySourceName);
-            this.activityName = activityName;
-        }
 
         public override void PreProcess(HttpContext context)
         {
diff --git a/test/OpenTelemetry.Instrumentation.AspNetCore.Tests/MetricTests.cs b/test/OpenTelemetry.Instrumentation.AspNetCore.Tests/MetricTests.cs
@@ -92,7 +92,7 @@ void ConfigureTestServices(IServiceCollection services)
         using (var client = this.factory
             .WithWebHostBuilder(builder =>
             {
-                builder.ConfigureTestServices(ConfigureTestServices);
+                builder.ConfigureServices(ConfigureTestServices);
             })
             .CreateClient())
         {
@@ -144,12 +144,11 @@ void ConfigureTestServices(IServiceCollection services)
         var routeMatchingMetric = exportedItems.
             Count(item => item.Name == "aspnetcore.routing.match_attempts");
 
-        // TODO
-        //var kestrelActiveConnectionsMetric = exportedItems.
-        //   Count(item => item.Name == "kestrel.active_connections");
+        var kestrelActiveConnectionsMetric = exportedItems.
+          Count(item => item.Name == "kestrel.active_connections");
 
-        //var kestrelQueuedConnectionMetric = exportedItems.
-        //   Count(item => item.Name == "kestrel.queued_connections");
+        var kestrelQueuedConnectionMetric = exportedItems.
+           Count(item => item.Name == "kestrel.queued_connections");
 
         Assert.Equal(1, requestDurationMetric);
         Assert.Equal(1, activeRequestsMetric);

Original file line number	Diff line number	Diff line change
`@@ -845,7 +845,8 @@ public async Task ShouldExportActivityWithOneOrMoreExceptionFilters(int mode)`
`845`	`845`	`public async Task DiagnosticSourceCallbacksAreReceivedOnlyForSubscribedEvents()`
`846`	`846`	`{`
`847`	`847`	`int numberOfUnSubscribedEvents = 0;`
`848`		`- int numberofSubscribedEvents = 0;`
	`848`	`+ int numberOfSubscribedEvents = 0;`
	`849`	`+`
`849`	`850`	`void ConfigureTestServices(IServiceCollection services)`
`850`	`851`	`{`
`851`	`852`	`this.tracerProvider = Sdk.CreateTracerProviderBuilder()`
`@@ -858,19 +859,19 @@ void ConfigureTestServices(IServiceCollection services)`
`858`	`859`	`{`
`859`	`860`	`case HttpInListener.OnStartEvent:`
`860`	`861`	`{`
`861`		`- numberofSubscribedEvents++;`
	`862`	`+ numberOfSubscribedEvents++;`
`862`	`863`	`}`
`863`	`864`
`864`	`865`	`break;`
`865`	`866`	`case HttpInListener.OnStopEvent:`
`866`	`867`	`{`
`867`		`- numberofSubscribedEvents++;`
	`868`	`+ numberOfSubscribedEvents++;`
`868`	`869`	`}`
`869`	`870`
`870`	`871`	`break;`
`871`	`872`	`case HttpInListener.OnMvcBeforeActionEvent:`
`872`	`873`	`{`
`873`		`- numberofSubscribedEvents++;`
	`874`	`+ numberOfSubscribedEvents++;`
`874`	`875`	`}`
`875`	`876`
`876`	`877`	`break;`
`@@ -884,6 +885,10 @@ void ConfigureTestServices(IServiceCollection services)`
`884`	`885`	`},`
`885`	`886`	`})`
`886`	`887`	`.Build();`
	`888`	`+`
	`889`	`+ services.AddOpenTelemetry()`
	`890`	`+ .WithTracing(builder => builder`
	`891`	`+ .AddInstrumentation(() => this.tracerProvider));`
`887`	`892`	`}`
`888`	`893`
`889`	`894`	`// Arrange`
`@@ -902,15 +907,16 @@ void ConfigureTestServices(IServiceCollection services)`
`902`	`907`	`}`
`903`	`908`
`904`	`909`	`Assert.Equal(0, numberOfUnSubscribedEvents);`
`905`		`- Assert.Equal(3, numberofSubscribedEvents);`
	`910`	`+ Assert.Equal(3, numberOfSubscribedEvents);`
`906`	`911`	`}`
`907`	`912`
`908`	`913`	`[Fact]`
`909`	`914`	`public async Task DiagnosticSourceExceptionCallbackIsReceivedForUnHandledException()`
`910`	`915`	`{`
`911`	`916`	`int numberOfUnSubscribedEvents = 0;`
`912`		`- int numberofSubscribedEvents = 0;`
	`917`	`+ int numberOfSubscribedEvents = 0;`
`913`	`918`	`int numberOfExceptionCallbacks = 0;`
	`919`	`+`
`914`	`920`	`void ConfigureTestServices(IServiceCollection services)`
`915`	`921`	`{`
`916`	`922`	`this.tracerProvider = Sdk.CreateTracerProviderBuilder()`
`@@ -923,19 +929,19 @@ void ConfigureTestServices(IServiceCollection services)`
`923`	`929`	`{`
`924`	`930`	`case HttpInListener.OnStartEvent:`
`925`	`931`	`{`
`926`		`- numberofSubscribedEvents++;`
	`932`	`+ numberOfSubscribedEvents++;`
`927`	`933`	`}`
`928`	`934`
`929`	`935`	`break;`
`930`	`936`	`case HttpInListener.OnStopEvent:`
`931`	`937`	`{`
`932`		`- numberofSubscribedEvents++;`
	`938`	`+ numberOfSubscribedEvents++;`
`933`	`939`	`}`
`934`	`940`
`935`	`941`	`break;`
`936`	`942`	`case HttpInListener.OnMvcBeforeActionEvent:`
`937`	`943`	`{`
`938`		`- numberofSubscribedEvents++;`
	`944`	`+ numberOfSubscribedEvents++;`
`939`	`945`	`}`
`940`	`946`
`941`	`947`	`break;`
`@@ -945,7 +951,7 @@ void ConfigureTestServices(IServiceCollection services)`
`945`	`951`	`case HttpInListener.OnUnhandledHostingExceptionEvent:`
`946`	`952`	`case HttpInListener.OnUnHandledDiagnosticsExceptionEvent:`
`947`	`953`	`{`
`948`		`- numberofSubscribedEvents++;`
	`954`	`+ numberOfSubscribedEvents++;`
`949`	`955`	`numberOfExceptionCallbacks++;`
`950`	`956`	`}`
`951`	`957`
`@@ -960,6 +966,10 @@ void ConfigureTestServices(IServiceCollection services)`
`960`	`966`	`},`
`961`	`967`	`})`
`962`	`968`	`.Build();`
	`969`	`+`
	`970`	`+ services.AddOpenTelemetry()`
	`971`	`+ .WithTracing(builder => builder`
	`972`	`+ .AddInstrumentation(() => this.tracerProvider));`
`963`	`973`	`}`
`964`	`974`
`965`	`975`	`// Arrange`
`@@ -986,18 +996,20 @@ void ConfigureTestServices(IServiceCollection services)`
`986`	`996`
`987`	`997`	`Assert.Equal(1, numberOfExceptionCallbacks);`
`988`	`998`	`Assert.Equal(0, numberOfUnSubscribedEvents);`
`989`		`- Assert.Equal(4, numberofSubscribedEvents);`
	`999`	`+ Assert.Equal(4, numberOfSubscribedEvents);`
`990`	`1000`	`}`
`991`	`1001`
`992`	`1002`	`[Fact(Skip = "https://github.com/open-telemetry/opentelemetry-dotnet/issues/4884")]`
`993`	`1003`	`public async Task DiagnosticSourceExceptionCallBackIsNotReceivedForExceptionsHandledInMiddleware()`
`994`	`1004`	`{`
`995`	`1005`	`int numberOfUnSubscribedEvents = 0;`
`996`		`- int numberofSubscribedEvents = 0;`
	`1006`	`+ int numberOfSubscribedEvents = 0;`
`997`	`1007`	`int numberOfExceptionCallbacks = 0;`
`998`	`1008`
`999`		`- // configure SDK`
`1000`		`- using var tracerprovider = Sdk.CreateTracerProviderBuilder()`
	`1009`	`+ void ConfigureTestServices(IServiceCollection services)`
	`1010`	`+ {`
	`1011`	`+ // configure SDK`
	`1012`	`+ this.tracerProvider = Sdk.CreateTracerProviderBuilder()`
`1001`	`1013`	`.AddAspNetCoreInstrumentation(`
`1002`	`1014`	`new TestHttpInListener(new AspNetCoreInstrumentationOptions())`
`1003`	`1015`	`{`
`@@ -1007,13 +1019,13 @@ public async Task DiagnosticSourceExceptionCallBackIsNotReceivedForExceptionsHan`
`1007`	`1019`	`{`
`1008`	`1020`	`case HttpInListener.OnStartEvent:`
`1009`	`1021`	`{`
`1010`		`- numberofSubscribedEvents++;`
	`1022`	`+ numberOfSubscribedEvents++;`
`1011`	`1023`	`}`
`1012`	`1024`
`1013`	`1025`	`break;`
`1014`	`1026`	`case HttpInListener.OnStopEvent:`
`1015`	`1027`	`{`
`1016`		`- numberofSubscribedEvents++;`
	`1028`	`+ numberOfSubscribedEvents++;`
`1017`	`1029`	`}`
`1018`	`1030`
`1019`	`1031`	`break;`
`@@ -1023,7 +1035,7 @@ public async Task DiagnosticSourceExceptionCallBackIsNotReceivedForExceptionsHan`
`1023`	`1035`	`case HttpInListener.OnUnhandledHostingExceptionEvent:`
`1024`	`1036`	`case HttpInListener.OnUnHandledDiagnosticsExceptionEvent:`
`1025`	`1037`	`{`
`1026`		`- numberofSubscribedEvents++;`
	`1038`	`+ numberOfSubscribedEvents++;`
`1027`	`1039`	`numberOfExceptionCallbacks++;`
`1028`	`1040`	`}`
`1029`	`1041`
`@@ -1039,45 +1051,43 @@ public async Task DiagnosticSourceExceptionCallBackIsNotReceivedForExceptionsHan`
`1039`	`1051`	`})`
`1040`	`1052`	`.Build();`
`1041`	`1053`
`1042`		`- var builder = WebApplication.CreateBuilder();`
`1043`		`- builder.Logging.ClearProviders();`
`1044`		`- var app = builder.Build();`
	`1054`	`+ services.AddOpenTelemetry()`
	`1055`	`+ .WithTracing(builder => builder`
	`1056`	`+ .AddInstrumentation(() => this.tracerProvider));`
	`1057`	`+ }`
`1045`	`1058`
`1046`		`- app.UseExceptionHandler(handler =>`
`1047`		`- {`
`1048`		`- handler.Run(async (ctx) =>`
	`1059`	`+ using (var client = this.factory`
	`1060`	`+ .WithWebHostBuilder(builder =>`
`1049`	`1061`	`{`
`1050`		`- await ctx.Response.WriteAsync("handled").ConfigureAwait(false);`
`1051`		`- });`
`1052`		`- });`
`1053`		`-`
`1054`		`- app.Map("/error", ThrowException);`
`1055`		`-`
`1056`		`- static void ThrowException(IApplicationBuilder app)`
	`1062`	`+ builder.ConfigureTestServices(ConfigureTestServices);`
	`1063`	`+ builder.ConfigureLogging(loggingBuilder => loggingBuilder.ClearProviders());`
	`1064`	`+ builder.Configure(app => app`
	`1065`	`+ .UseExceptionHandler(handler =>`
	`1066`	`+ {`
	`1067`	`+ handler.Run(async (ctx) =>`
	`1068`	`+ {`
	`1069`	`+ await ctx.Response.WriteAsync("handled").ConfigureAwait(false);`
	`1070`	`+ });`
	`1071`	`+ }));`
	`1072`	`+ })`
	`1073`	`+ .CreateClient())`
`1057`	`1074`	`{`
`1058`		`- app.Run(context =>`
	`1075`	`+ try`
`1059`	`1076`	`{`
`1060`		`- throw new Exception("CustomException");`
`1061`		`- });`
`1062`		`- }`
`1063`		`-`
`1064`		`- _ = app.RunAsync();`
	`1077`	`+ using var request = new HttpRequestMessage(HttpMethod.Get, "/api/error");`
`1065`	`1078`
`1066`		`- using var client = new HttpClient();`
`1067`		`- try`
`1068`		`- {`
`1069`		`- await client.GetStringAsync("http://localhost:5000/error").ConfigureAwait(false);`
`1070`		`- }`
`1071`		`- catch`
`1072`		`- {`
`1073`		`- // ignore 500 error.`
	`1079`	`+ // Act`
	`1080`	`+ using var response = await client.SendAsync(request).ConfigureAwait(false);`
	`1081`	`+ }`
	`1082`	`+ catch`
	`1083`	`+ {`
	`1084`	`+ // ignore exception`
	`1085`	`+ }`
`1074`	`1086`	`}`
`1075`	`1087`
`1076`	`1088`	`Assert.Equal(0, numberOfExceptionCallbacks);`
`1077`	`1089`	`Assert.Equal(0, numberOfUnSubscribedEvents);`
`1078`		`- Assert.Equal(2, numberofSubscribedEvents);`
`1079`		`-`
`1080`		`- await app.DisposeAsync().ConfigureAwait(false);`
	`1090`	`+ Assert.Equal(2, numberOfSubscribedEvents);`
`1081`	`1091`	`}`
`1082`	`1092`
`1083`	`1093`	`[Fact]`
`@@ -1093,8 +1103,6 @@ void ConfigureTestServices(IServiceCollection services)`
`1093`	`1103`	`.AddInMemoryExporter(exportedItems)`
`1094`	`1104`	`.Build();`
`1095`	`1105`
`1096`		`- var meterFactory = this.factory.Services.GetRequiredService<IMeterFactory>();`
`1097`		`- services.AddSingleton(meterFactory);`
`1098`	`1106`	`services.AddRouting();`
`1099`	`1107`	`services.AddOpenTelemetry()`
`1100`	`1108`	`.WithTracing(builder =>`
`@@ -1220,16 +1228,10 @@ private void ConfigureExceptionFilters(IServiceCollection services, int mode, re`
`1220`	`1228`	`.Build();`
`1221`	`1229`	`}`
`1222`	`1230`
`1223`		`- private class ExtractOnlyPropagator : TextMapPropagator`
	`1231`	`+ private class ExtractOnlyPropagator(ActivityContext activityContext, Baggage baggage) : TextMapPropagator`
`1224`	`1232`	`{`
`1225`		`- private readonly ActivityContext activityContext;`
`1226`		`- private readonly Baggage baggage;`
`1227`		`-`
`1228`		`- public ExtractOnlyPropagator(ActivityContext activityContext, Baggage baggage)`
`1229`		`- {`
`1230`		`- this.activityContext = activityContext;`
`1231`		`- this.baggage = baggage;`
`1232`		`- }`
	`1233`	`+ private readonly ActivityContext activityContext = activityContext;`
	`1234`	`+ private readonly Baggage baggage = baggage;`
`1233`	`1235`
`1234`	`1236`	`public override ISet<string> Fields => throw new NotImplementedException();`
`1235`	`1237`
`@@ -1244,32 +1246,21 @@ public override void Inject<T>(PropagationContext context, T carrier, Action<T,`
`1244`	`1246`	`}`
`1245`	`1247`	`}`
`1246`	`1248`
`1247`		`- private class TestSampler : Sampler`
	`1249`	`+ private class TestSampler(SamplingDecision samplingDecision, IEnumerable<KeyValuePair<string, object>> attributes = null) : Sampler`
`1248`	`1250`	`{`
`1249`		`- private readonly SamplingDecision samplingDecision;`
`1250`		`- private readonly IEnumerable<KeyValuePair<string, object>> attributes;`
`1251`		`-`
`1252`		`- public TestSampler(SamplingDecision samplingDecision, IEnumerable<KeyValuePair<string, object>> attributes = null)`
`1253`		`- {`
`1254`		`- this.samplingDecision = samplingDecision;`
`1255`		`- this.attributes = attributes;`
`1256`		`- }`
	`1251`	`+ private readonly SamplingDecision samplingDecision = samplingDecision;`
	`1252`	`+ private readonly IEnumerable<KeyValuePair<string, object>> attributes = attributes;`
`1257`	`1253`
`1258`	`1254`	`public override SamplingResult ShouldSample(in SamplingParameters samplingParameters)`
`1259`	`1255`	`{`
`1260`	`1256`	`return new SamplingResult(this.samplingDecision, this.attributes);`
`1261`	`1257`	`}`
`1262`	`1258`	`}`
`1263`	`1259`
`1264`		`- private class TestHttpInListener : HttpInListener`
	`1260`	`+ private class TestHttpInListener(AspNetCoreInstrumentationOptions options) : HttpInListener(options)`
`1265`	`1261`	`{`
`1266`	`1262`	`public Action<string, object> OnEventWrittenCallback;`
`1267`	`1263`
`1268`		`- public TestHttpInListener(AspNetCoreInstrumentationOptions options)`
`1269`		`- : base(options)`
`1270`		`- {`
`1271`		`- }`
`1272`		`-`
`1273`	`1264`	`public override void OnEventWritten(string name, object payload)`
`1274`	`1265`	`{`
`1275`	`1266`	`base.OnEventWritten(name, payload);`
`@@ -1278,17 +1269,11 @@ public override void OnEventWritten(string name, object payload)`
`1278`	`1269`	`}`
`1279`	`1270`	`}`
`1280`	`1271`
`1281`		`- private class TestNullHostActivityMiddlewareImpl : ActivityMiddleware.ActivityMiddlewareImpl`
	`1272`	`+ private class TestNullHostActivityMiddlewareImpl(string activitySourceName, string activityName) : ActivityMiddleware.ActivityMiddlewareImpl`
`1282`	`1273`	`{`
`1283`		`- private ActivitySource activitySource;`
	`1274`	`+ private readonly ActivitySource activitySource = new(activitySourceName);`
	`1275`	`+ private readonly string activityName = activityName;`
`1284`	`1276`	`private Activity activity;`
`1285`		`- private string activityName;`
`1286`		`-`
`1287`		`- public TestNullHostActivityMiddlewareImpl(string activitySourceName, string activityName)`
`1288`		`- {`
`1289`		`- this.activitySource = new ActivitySource(activitySourceName);`
`1290`		`- this.activityName = activityName;`
`1291`		`- }`
`1292`	`1277`
`1293`	`1278`	`public override void PreProcess(HttpContext context)`
`1294`	`1279`	`{`
`@@ -1306,17 +1291,11 @@ public override void PostProcess(HttpContext context)`
`1306`	`1291`	`}`
`1307`	`1292`	`}`
`1308`	`1293`
`1309`		`- private class TestActivityMiddlewareImpl : ActivityMiddleware.ActivityMiddlewareImpl`
	`1294`	`+ private class TestActivityMiddlewareImpl(string activitySourceName, string activityName) : ActivityMiddleware.ActivityMiddlewareImpl`
`1310`	`1295`	`{`
`1311`		`- private ActivitySource activitySource;`
	`1296`	`+ private readonly ActivitySource activitySource = new(activitySourceName);`
	`1297`	`+ private readonly string activityName = activityName;`
`1312`	`1298`	`private Activity activity;`
`1313`		`- private string activityName;`
`1314`		`-`
`1315`		`- public TestActivityMiddlewareImpl(string activitySourceName, string activityName)`
`1316`		`- {`
`1317`		`- this.activitySource = new ActivitySource(activitySourceName);`
`1318`		`- this.activityName = activityName;`
`1319`		`- }`
`1320`	`1299`
`1321`	`1300`	`public override void PreProcess(HttpContext context)`
`1322`	`1301`	`{`