draft

docs/trace/getting-started-aspnetcore/InstrumentationOptions.cs

@@ -0,0 +1,22 @@
+// <copyright file="InstrumentationOptions.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+public class InstrumentationOptions
+{
+    public bool EnableInstrumentation { get; set; }
+
+    public bool EnableMiddlewareInstrumentation { get; set; }
+}

docs/trace/getting-started-aspnetcore/Program.cs

@@ -15,21 +15,53 @@
 // </copyright>
 
 using System.Diagnostics;
+using OpenTelemetry.Instrumentation.AspNetCore;
+using OpenTelemetry.Instrumentation.AspNetCore.Implementation;
 using OpenTelemetry.Resources;
 using OpenTelemetry.Trace;
 
 var builder = WebApplication.CreateBuilder(args);
 
+var instrumentationOptions = new InstrumentationOptions();
+
+builder.Configuration.GetSection("InstrumentationOptions").Bind(instrumentationOptions);
+
+Console.WriteLine("EnableInstrumentation: " + instrumentationOptions.EnableInstrumentation);
+Console.WriteLine("EnableMiddlewareInstrumentation: " + instrumentationOptions.EnableMiddlewareInstrumentation);
+
 // Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => resource
+if (instrumentationOptions.EnableInstrumentation)
+{
+    builder.Services.AddOpenTelemetry()
+        .ConfigureResource(resource => resource
         .AddService(serviceName: builder.Environment.ApplicationName))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddConsoleExporter());
+        .WithTracing(tracing => tracing
+        .AddAspNetCoreInstrumentation());
+}
 
+if (instrumentationOptions.EnableMiddlewareInstrumentation)
+{
+    ActivitySource.AddActivityListener(new ActivityListener
+    {
+        ShouldListenTo = source => source.Name == "Microsoft.AspNetCore",
+        Sample = (ref ActivityCreationOptions<ActivityContext> options) => ActivitySamplingResult.AllDataAndRecorded,
+        ActivityStarted = activity => { },
+        ActivityStopped = activity => { },
+    });
+    builder.Services.AddSingleton(new TelemetryMiddleware(new AspNetCoreTraceInstrumentationOptions()));
+}
+
+builder.Logging.ClearProviders();
 var app = builder.Build();
 
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
+if (instrumentationOptions.EnableMiddlewareInstrumentation)
+{
+    app.UseMiddleware<TelemetryMiddleware>();
+}
+
+app.MapGet("/", () =>
+{
+    return $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}";
+});
 
 app.Run();

docs/trace/getting-started-aspnetcore/appsettings.json

@@ -5,5 +5,9 @@
       "Microsoft.AspNetCore": "Warning"
     }
   },
+  "InstrumentationOptions": {
+    "EnableInstrumentation": true,
+    "EnableMiddlewareInstrumentation": false
+  },
   "AllowedHosts": "*"
 }

src/OpenTelemetry.Instrumentation.AspNetCore/.publicApi/PublicAPI.Unshipped.txt

@@ -10,9 +10,13 @@ OpenTelemetry.Instrumentation.AspNetCore.AspNetCoreTraceInstrumentationOptions.F
 OpenTelemetry.Instrumentation.AspNetCore.AspNetCoreTraceInstrumentationOptions.Filter.set -> void
 OpenTelemetry.Instrumentation.AspNetCore.AspNetCoreTraceInstrumentationOptions.RecordException.get -> bool
 OpenTelemetry.Instrumentation.AspNetCore.AspNetCoreTraceInstrumentationOptions.RecordException.set -> void
+OpenTelemetry.Instrumentation.AspNetCore.Implementation.TelemetryMiddleware
+OpenTelemetry.Instrumentation.AspNetCore.Implementation.TelemetryMiddleware.InvokeAsync(Microsoft.AspNetCore.Http.HttpContext context, Microsoft.AspNetCore.Http.RequestDelegate next) -> System.Threading.Tasks.Task
+OpenTelemetry.Instrumentation.AspNetCore.Implementation.TelemetryMiddleware.TelemetryMiddleware(OpenTelemetry.Instrumentation.AspNetCore.AspNetCoreTraceInstrumentationOptions options) -> void
 OpenTelemetry.Metrics.MeterProviderBuilderExtensions
 OpenTelemetry.Trace.TracerProviderBuilderExtensions
 static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddAspNetCoreInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder builder) -> OpenTelemetry.Metrics.MeterProviderBuilder
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddAspNetCoreInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder builder) -> OpenTelemetry.Trace.TracerProviderBuilder
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddAspNetCoreInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder builder, string name, System.Action<OpenTelemetry.Instrumentation.AspNetCore.AspNetCoreTraceInstrumentationOptions> configureAspNetCoreTraceInstrumentationOptions) -> OpenTelemetry.Trace.TracerProviderBuilder
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddAspNetCoreInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder builder, System.Action<OpenTelemetry.Instrumentation.AspNetCore.AspNetCoreTraceInstrumentationOptions> configureAspNetCoreTraceInstrumentationOptions) -> OpenTelemetry.Trace.TracerProviderBuilder
+

src/OpenTelemetry.Instrumentation.AspNetCore/Implementation/TelemetryMiddleware.cs

@@ -0,0 +1,46 @@
+// <copyright file="TelemetryMiddleware.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using Microsoft.AspNetCore.Http;
+
+namespace OpenTelemetry.Instrumentation.AspNetCore.Implementation;
+
+/// <summary>
+/// Telemetry middleware.
+/// </summary>
+/// <remarks>
+/// Initializes a new instance of the <see cref="TelemetryMiddleware"/> class.
+/// </remarks>
+/// <param name="options">trace options.</param>
+public class TelemetryMiddleware(AspNetCoreTraceInstrumentationOptions options) : IMiddleware
+{
+    internal readonly HttpInListener InListener = new HttpInListener(options);
+
+    /// <inheritdoc/>
+    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
+    {
+        try
+        {
+            this.InListener.OnEventWritten("Microsoft.AspNetCore.Hosting.HttpRequestIn.Start", context);
+            await next(context).ConfigureAwait(false);
+            this.InListener.OnEventWritten("Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop", context);
+        }
+        catch
+        {
+            // Exception
+        }
+    }
+}

test/Benchmarks/Instrumentation/AspNetCoreInstrumentationNewBenchmarks.cs

@@ -15,13 +15,16 @@
 // </copyright>
 
 #if !NETFRAMEWORK
+using System.Diagnostics;
 using BenchmarkDotNet.Attributes;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using OpenTelemetry;
+using OpenTelemetry.Instrumentation.AspNetCore;
+using OpenTelemetry.Instrumentation.AspNetCore.Implementation;
 using OpenTelemetry.Metrics;
 using OpenTelemetry.Trace;
 
@@ -88,6 +91,7 @@ public class AspNetCoreInstrumentationNewBenchmarks
     private WebApplication app;
     private TracerProvider tracerProvider;
     private MeterProvider meterProvider;
+    private ActivityListener activityListener;
 
     [Flags]
     public enum EnableInstrumentationOption
@@ -106,6 +110,11 @@ public enum EnableInstrumentationOption
         /// Instrumentation is enbled only for Metrics.
         /// </summary>
         Metrics = 2,
+
+        /// <summary>
+        /// Instrumentation is enbled only for Metrics.
+        /// </summary>
+        Middleware = 3,
     }
 
     [Params(0, 1, 2, 3)]
@@ -119,7 +128,7 @@ public void GetRequestForAspNetCoreAppGlobalSetup()
             .AddInMemoryCollection(config)
             .Build();
 
-        if (this.EnableInstrumentation == EnableInstrumentationOption.None)
+        if (this.EnableInstrumentation == EnableInstrumentationOption.None || this.EnableInstrumentation.HasFlag(EnableInstrumentationOption.Middleware))
         {
             this.StartWebApplication();
             this.httpClient = new HttpClient();
@@ -175,8 +184,13 @@ public void GetRequestForAspNetCoreAppGlobalSetup()
     [GlobalCleanup(Target = nameof(GetRequestForAspNetCoreApp))]
     public void GetRequestForAspNetCoreAppGlobalCleanup()
     {
-        if (this.EnableInstrumentation == EnableInstrumentationOption.None)
+        if (this.EnableInstrumentation == EnableInstrumentationOption.None || this.EnableInstrumentation.HasFlag(EnableInstrumentationOption.Middleware))
         {
+            if (this.EnableInstrumentation.HasFlag(EnableInstrumentationOption.Middleware))
+            {
+                this.activityListener.Dispose();
+            }
+
             this.httpClient.Dispose();
             this.app.DisposeAsync().GetAwaiter().GetResult();
         }
@@ -212,8 +226,28 @@ public async Task GetRequestForAspNetCoreApp()
     private void StartWebApplication()
     {
         var builder = WebApplication.CreateBuilder();
+        if (this.EnableInstrumentation.HasFlag(EnableInstrumentationOption.Middleware))
+        {
+            this.activityListener = new ActivityListener
+            {
+                ShouldListenTo = source => source.Name == "Microsoft.AspNetCore",
+                Sample = (ref ActivityCreationOptions<ActivityContext> options) => ActivitySamplingResult.AllDataAndRecorded,
+                ActivityStarted = activity => { },
+                ActivityStopped = activity => { },
+            };
+
+            ActivitySource.AddActivityListener(this.activityListener);
+            builder.Services.AddSingleton(new TelemetryMiddleware(new AspNetCoreTraceInstrumentationOptions()));
+        }
+
         builder.Logging.ClearProviders();
         var app = builder.Build();
+
+        if (this.EnableInstrumentation.HasFlag(EnableInstrumentationOption.Middleware))
+        {
+            app.UseMiddleware<TelemetryMiddleware>();
+        }
+
         app.MapGet("/", async context => await context.Response.WriteAsync($"Hello World!"));
         app.RunAsync();
 

test/OpenTelemetry.Tests.Stress/Meat.cs

@@ -14,19 +14,56 @@
 // limitations under the License.
 // </copyright>
 
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
+#if NET6_0_OR_GREATER
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+#endif
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry.Tests.Stress;
 
 public partial class Program
 {
+    public static TracerProvider? TracerProvider;
+    public static ActivitySource? ActivitySource = new ActivitySource("MySource");
+#if NET6_0_OR_GREATER
+    private static WebApplication? app;
+    private static HttpClient? httpClient;
+#endif
+
     public static void Main()
     {
-        Stress(concurrency: 1, prometheusPort: 9464);
+#if NET6_0_OR_GREATER
+        TracerProvider = Sdk.CreateTracerProviderBuilder()
+            .AddAspNetCoreInstrumentation()
+            .Build();
+        var builder = WebApplication.CreateBuilder();
+        builder.Logging.ClearProviders();
+        var app = builder.Build();
+        app.MapGet("/", async context => await context.Response.WriteAsync($"Hello World!"));
+        app.RunAsync();
+
+        Program.app = app;
+        httpClient = new HttpClient();
+#endif
+        Stress(concurrency: 0, prometheusPort: 9464);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     protected static void Run()
     {
+#if NET6_0_OR_GREATER
+        if (httpClient != null)
+        {
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Get;
+            message.RequestUri = new Uri("http://localhost:5000");
+            var httpResponse = httpClient.Send(message);
+            httpResponse?.EnsureSuccessStatusCode();
+        }
+#endif
     }
 }

test/OpenTelemetry.Tests.Stress/OpenTelemetry.Tests.Stress.csproj

@@ -12,4 +12,9 @@
   <ItemGroup>
     <ProjectReference Include="$(RepoRoot)\src\OpenTelemetry.Exporter.Prometheus.HttpListener\OpenTelemetry.Exporter.Prometheus.HttpListener.csproj" />
   </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+    <ProjectReference Include="$(RepoRoot)\src\OpenTelemetry.Instrumentation.AspNetCore\OpenTelemetry.Instrumentation.AspNetCore.csproj" />
+  </ItemGroup>
 </Project>