Instrumentation Adapters to support Activity API

samples/Exporters/Web/OpenTelemetry.Exporter.Web.csproj

@@ -12,6 +12,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\..\src\OpenTelemetry.Exporter.Console\OpenTelemetry.Exporter.Console.csproj" />
     <ProjectReference Include="..\..\..\src\OpenTelemetry.Instrumentation.AspNetCore\OpenTelemetry.Instrumentation.AspNetCore.csproj" />
     <ProjectReference Include="..\..\..\src\OpenTelemetry.Instrumentation.Dependencies\OpenTelemetry.Instrumentation.Dependencies.csproj" />
     <ProjectReference Include="..\..\..\src\OpenTelemetry.Exporter.Zipkin\OpenTelemetry.Exporter.Zipkin.csproj" />

samples/Exporters/Web/Startup.cs

@@ -7,6 +7,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.OpenApi.Models;
+using OpenTelemetry.Exporter.Console;
 using OpenTelemetry.Trace.Configuration;
 
 namespace API
@@ -36,6 +37,10 @@ public void ConfigureServices(IServiceCollection services)
                 }
             });
 
+            OpenTelemetrySdk.EnableOpenTelemetry(
+                (builder) => builder.AddRequestInstrumentation()
+                .UseConsoleActivityExporter(opt => opt.DisplayAsJson = opt.DisplayAsJson));
+
             services.AddOpenTelemetry((sp, builder) =>
             {
                 builder
@@ -45,7 +50,6 @@ public void ConfigureServices(IServiceCollection services)
                         options.ServiceName = "test-zipkin";
                         options.Endpoint = new Uri(this.Configuration.GetValue<string>("Zipkin:Endpoint"));
                     })
-                    .AddRequestInstrumentation()
                     .AddDependencyInstrumentation();
             });
         }

src/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreInstrumentation.cs

@@ -15,7 +15,6 @@
 // </copyright>
 using System;
 using OpenTelemetry.Instrumentation.AspNetCore.Implementation;
-using OpenTelemetry.Trace;
 
 namespace OpenTelemetry.Instrumentation.AspNetCore
 {
@@ -29,20 +28,18 @@ public class AspNetCoreInstrumentation : IDisposable
         /// <summary>
         /// Initializes a new instance of the <see cref="AspNetCoreInstrumentation"/> class.
         /// </summary>
-        /// <param name="tracer">Tracer to record traced with.</param>
-        public AspNetCoreInstrumentation(Tracer tracer)
-            : this(tracer, new AspNetCoreInstrumentationOptions())
+        public AspNetCoreInstrumentation()
+            : this(new AspNetCoreInstrumentationOptions())
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="AspNetCoreInstrumentation"/> class.
         /// </summary>
-        /// <param name="tracer">Tracer to record traced with.</param>
         /// <param name="options">Configuration options for ASP.NET Core instrumentation.</param>
-        public AspNetCoreInstrumentation(Tracer tracer, AspNetCoreInstrumentationOptions options)
+        public AspNetCoreInstrumentation(AspNetCoreInstrumentationOptions options)
         {
-            this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber(new HttpInListener("Microsoft.AspNetCore", tracer, options), null);
+            this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber(new HttpInListener("Microsoft.AspNetCore", options), null);
             this.diagnosticSourceSubscriber.Subscribe();
         }
 

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

@@ -36,8 +36,8 @@ internal class HttpInListener : ListenerHandler
         private readonly bool hostingSupportsW3C = false;
         private readonly AspNetCoreInstrumentationOptions options;
 
-        public HttpInListener(string name, Tracer tracer, AspNetCoreInstrumentationOptions options)
-            : base(name, tracer)
+        public HttpInListener(string name, AspNetCoreInstrumentationOptions options)
+            : base(name, null)
         {
             this.hostingSupportsW3C = typeof(HttpRequest).Assembly.GetName().Version.Major >= 3;
             this.options = options ?? throw new ArgumentNullException(nameof(options));
@@ -60,50 +60,57 @@ public override void OnStartActivity(Activity activity, object payload)
                 return;
             }
 
-            var request = context.Request;
+            // TODO: the line below once .NET ships new Activity
+            // Or do reflection now.
+            // activity.ActivityKind = ActivityKind.Server
 
-            // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/data-semantic-conventions.md
-            var path = (request.PathBase.HasValue || request.Path.HasValue) ? (request.PathBase + request.Path).ToString() : "/";
+            var request = context.Request;
 
-            TelemetrySpan span;
-            if (this.hostingSupportsW3C && this.options.TextFormat is TraceContextFormat)
-            {
-                this.Tracer.StartActiveSpanFromActivity(path, Activity.Current, SpanKind.Server, out span);
-            }
-            else
+            if (!this.hostingSupportsW3C || !(this.options.TextFormat is TraceContextFormat))
             {
+                // This requires to ignore the current activity and create a new one
+                // using the context extracted from w3ctraceprent header or
+                // using the format TextFormat supports.
+                // TODO: actually implement code doing the above.
+
+                /*
                 var ctx = this.options.TextFormat.Extract<HttpRequest>(
                     request,
                     (r, name) => r.Headers[name]);
 
                 this.Tracer.StartActiveSpan(path, ctx, SpanKind.Server, out span);
+                */
             }
 
-            if (span.IsRecording)
+            if (activity.IsAllDataRequested)
             {
-                // Note, route is missing at this stage. It will be available later
-                span.PutHttpHostAttribute(request.Host.Host, request.Host.Port ?? 80);
-                span.PutHttpMethodAttribute(request.Method);
-                span.PutHttpPathAttribute(path);
+                // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/data-semantic-conventions.md
+                var path = (request.PathBase.HasValue || request.Path.HasValue) ? (request.PathBase + request.Path).ToString() : "/";
+                activity.DisplayName = path;
+
+                if (request.Host.Port == 80 || request.Host.Port == 443)
+                {
+                    activity.AddTag("http.host", request.Host.Host);
+                }
+                else
+                {
+                    activity.AddTag("http.host", request.Host.Host + ":" + request.Host.Port);
+                }
+
+                activity.AddTag("http.method", request.Method);
+                activity.AddTag("http.path", path);
 
                 var userAgent = request.Headers["User-Agent"].FirstOrDefault();
-                span.PutHttpUserAgentAttribute(userAgent);
-                span.PutHttpRawUrlAttribute(GetUri(request));
+                activity.AddTag("http.user_agent", userAgent);
+                activity.AddTag("http.url", GetUri(request));
             }
         }
 
         public override void OnStopActivity(Activity activity, object payload)
         {
             const string EventNameSuffix = ".OnStopActivity";
-            var span = this.Tracer.CurrentSpan;
 
-            if (span == null || !span.Context.IsValid)
-            {
-                InstrumentationEventSource.Log.NullOrBlankSpan(nameof(HttpInListener) + EventNameSuffix);
-                return;
-            }
-
-            if (span.IsRecording)
+            if (activity.IsAllDataRequested)
             {
                 if (!(this.stopContextFetcher.Fetch(payload) is HttpContext context))
                 {
@@ -112,26 +119,19 @@ public override void OnStopActivity(Activity activity, object payload)
                 }
 
                 var response = context.Response;
+                activity.AddTag(SpanAttributeConstants.HttpStatusCodeKey, response.StatusCode.ToString());
 
-                span.PutHttpStatusCode(response.StatusCode, response.HttpContext.Features.Get<IHttpResponseFeature>().ReasonPhrase);
+                Status status = SpanHelper.ResolveSpanStatusForHttpStatusCode((int)response.StatusCode);
+                activity.AddTag(SpanAttributeConstants.StatusCodeKey, SpanHelper.GetCachedCanonicalCodeString(status.CanonicalCode));
+                activity.AddTag(SpanAttributeConstants.StatusDescriptionKey, response.HttpContext.Features.Get<IHttpResponseFeature>().ReasonPhrase);
             }
-
-            span.End();
         }
 
         public override void OnCustom(string name, Activity activity, object payload)
         {
             if (name == "Microsoft.AspNetCore.Mvc.BeforeAction")
             {
-                var span = this.Tracer.CurrentSpan;
-
-                if (span == null)
-                {
-                    InstrumentationEventSource.Log.NullOrBlankSpan(name);
-                    return;
-                }
-
-                if (span.IsRecording)
+                if (activity.IsAllDataRequested)
                 {
                     // See https://github.com/aspnet/Mvc/blob/2414db256f32a047770326d14d8b0e2afd49ba49/src/Microsoft.AspNetCore.Mvc.Core/MvcCoreDiagnosticSourceExtensions.cs#L36-L44
                     // Reflection accessing: ActionDescriptor.AttributeRouteInfo.Template
@@ -145,9 +145,8 @@ public override void OnCustom(string name, Activity activity, object payload)
                     if (!string.IsNullOrEmpty(template))
                     {
                         // override the span name that was previously set to the path part of URL.
-                        span.UpdateName(template);
-
-                        span.PutHttpRouteAttribute(template);
+                        activity.DisplayName = template;
+                        activity.AddTag(SpanAttributeConstants.HttpRouteKey, template);
                     }
 
                     // TODO: Should we get values from RouteData?

src/OpenTelemetry.Instrumentation.AspNetCore/OpenTelemetryBuilderExtensions.cs

@@ -0,0 +1,52 @@
+// <copyright file="OpenTelemetryBuilderExtensions.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 System;
+using OpenTelemetry.Instrumentation.AspNetCore;
+
+namespace OpenTelemetry.Trace.Configuration
+{
+    /// <summary>
+    /// Extension methods to simplify registering of asp.net core request instrumentation.
+    /// </summary>
+    public static class OpenTelemetryBuilderExtensions
+    {
+        /// <summary>
+        /// Enables the incoming requests automatic data collection for Asp.Net Core.
+        /// </summary>
+        /// <param name="builder"><see cref="OpenTelemetryBuilder"/> being configured.</param>
+        /// <param name="configureAspNetCoreInstrumentationOptions">ASP.NET Core Request configuration options.</param>
+        /// <returns>The instance of <see cref="OpenTelemetryBuilder"/> to chain the calls.</returns>
+        public static OpenTelemetryBuilder AddRequestInstrumentation(
+            this OpenTelemetryBuilder builder,
+            Action<AspNetCoreInstrumentationOptions> configureAspNetCoreInstrumentationOptions = null)
+        {
+            if (builder == null)
+            {
+                throw new ArgumentNullException(nameof(builder));
+            }
+
+            builder.AddActivitySource(string.Empty);
+            var aspnetCoreOptions = new AspNetCoreInstrumentationOptions();
+            configureAspNetCoreInstrumentationOptions?.Invoke(aspnetCoreOptions);
+
+            // TODO: decide who is responsible for dispose upon shutdown.
+            new AspNetCoreInstrumentation(aspnetCoreOptions);
+
+            return builder;
+        }
+    }
+}

src/OpenTelemetry/Trace/Export/SimpleActivityProcessor.cs

@@ -18,6 +18,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using OpenTelemetry.Internal;
+using OpenTelemetry.Trace.Samplers;
 
 namespace OpenTelemetry.Trace.Export
 {
@@ -27,6 +28,7 @@ namespace OpenTelemetry.Trace.Export
     public class SimpleActivityProcessor : ActivityProcessor, IDisposable
     {
         private readonly ActivityExporter exporter;
+        private readonly ActivitySampler sampler = new AlwaysOnActivitySampler();
         private bool disposed = false;
 
         /// <summary>
@@ -41,6 +43,16 @@ public SimpleActivityProcessor(ActivityExporter exporter)
         /// <inheritdoc />
         public override void OnStart(Activity activity)
         {
+            // Perform sampling decision if source is empty.
+            // This occurs for activities created outside of ActivitySource
+            // i.e new Activity() directly.
+            // Note: This also can occur if one creates an ActivitySource of the name string.empty.
+            // In that case, the sampling logic would be run twice!
+            if (activity.Source.Name.Equals(string.Empty))
+            {
+                var samplingDecision = this.sampler.ShouldSample(activity.Context, activity.TraceId, default, activity.DisplayName, activity.Kind, activity.Tags, activity.Links);
+                activity.IsAllDataRequested = samplingDecision.IsSampled;
+            }
         }
 
         /// <inheritdoc />