Capture http.server.duration metric for ASP.NET Core instrumentation

src/OpenTelemetry.Api/Internal/SemanticConventions.cs

@@ -110,6 +110,13 @@ internal static class SemanticConventions
         public const string AttributeExceptionType = "exception.type";
         public const string AttributeExceptionMessage = "exception.message";
         public const string AttributeExceptionStacktrace = "exception.stacktrace";
+
+        // TODO: This class is currently in the OpenTelemetry.Trace namespace.
+        // We could create a new SemanticConventions class in the OpenTelemetry.Metrics namespace,
+        // though this may be a little strange since many of the attribute names within this class
+        // are used for both traces and metrics.
+        // Another option would be to move this class to the OpenTelemetry namespace.
+        public const string MetricHttpServerDuration = "http.server.duration";
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
     }
 }

src/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreMetrics.cs

@@ -0,0 +1,46 @@
+// <copyright file="AspNetCoreMetrics.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.Implementation;
+using OpenTelemetry.Metrics;
+
+namespace OpenTelemetry.Instrumentation.AspNetCore
+{
+    /// <summary>
+    /// Asp.Net Core Requests instrumentation.
+    /// </summary>
+    internal class AspNetCoreMetrics : IDisposable
+    {
+        private readonly DiagnosticSourceSubscriber diagnosticSourceSubscriber;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AspNetCoreMetrics"/> class.
+        /// </summary>
+        /// <param name="meter">The meter for obtaining metric instruments.</param>
+        public AspNetCoreMetrics(Meter meter)
+        {
+            this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber(new HttpInMetricsListener("Microsoft.AspNetCore", meter), null);
+            this.diagnosticSourceSubscriber.Subscribe();
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            this.diagnosticSourceSubscriber?.Dispose();
+        }
+    }
+}

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

@@ -0,0 +1,99 @@
+// <copyright file="HttpInMetricsListener.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 System.Collections.Generic;
+using System.Diagnostics;
+using Microsoft.AspNetCore.Http;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry.Instrumentation.AspNetCore.Implementation
+{
+    internal class HttpInMetricsListener : ListenerHandler
+    {
+        private readonly PropertyFetcher<HttpContext> stopContextFetcher = new PropertyFetcher<HttpContext>("HttpContext");
+        private readonly Meter meter;
+
+        private MeasureMetric<double> httpServerDuration;
+
+        public HttpInMetricsListener(string name, Meter meter)
+            : base(name)
+        {
+            this.meter = meter;
+        }
+
+        public override void OnStopActivity(Activity activity, object payload)
+        {
+            HttpContext context = this.stopContextFetcher.Fetch(payload);
+            if (context == null)
+            {
+                AspNetCoreInstrumentationEventSource.Log.NullPayload(nameof(HttpInMetricsListener), nameof(this.OnStopActivity));
+                return;
+            }
+
+            // TODO: Prometheus pulls metrics by invoking the /metrics endpoint. Decide if it makes sense to suppress this.
+            // Below is just a temporary way of achieving this suppression for metrics (we should consider suppressing traces too).
+            // If we want to suppress activity from Prometheus then we should use SuppressInstrumentationScope.
+            if (context.Request.Path.HasValue && context.Request.Path.Value.Contains("metrics"))
+            {
+                return;
+            }
+
+            var labels = new Dictionary<string, string>(StringComparer.Ordinal);
+
+            labels[SemanticConventions.AttributeHttpMethod] = context.Request.Method;
+
+            labels[SemanticConventions.AttributeHttpScheme] = context.Request.Scheme;
+
+            if (context.Request.Host.HasValue)
+            {
+                labels[SemanticConventions.AttributeHttpHost] = context.Request.Host.Value;
+                labels[SemanticConventions.AttributeNetHostName] = context.Request.Host.Host;
+
+                if (context.Request.Host.Port.HasValue)
+                {
+                    labels[SemanticConventions.AttributeNetHostPort] = context.Request.Host.Port.ToString();
+                }
+            }
+
+            labels[SemanticConventions.AttributeHttpStatusCode] = context.Response.StatusCode.ToString();
+            labels[SemanticConventions.AttributeHttpFlavor] = context.Request.Protocol;
+
+            // TODO: Decide if/how to handle http.server_name. Spec seems to suggest
+            // preference for net.host.name.
+            // labels[SemanticConventions.AttributeHttpServerName] = string.Empty;
+
+            // TODO: Decide if we want http.url. It seems awful from a cardinality perspective.
+            // Retrieving the route data and setting http.target probably makes more sense.
+            // labels[SemanticConventions.AttributeHttpUrl] = string.Empty;
+
+            // TODO: Retrieve the route.
+            // labels[SemanticConventions.AttributeHttpTarget] = string.Empty;
+
+            // TODO: Ideally we could do this in the constructor. However, the instrumentation is usually instantiated
+            // prior to invoking MeterProvider.SetDefault. Setting the default meter provider is required before metrics
+            // can be created.
+            // This should be safe in the meantime since CreateDoubleMeasure uses a ConcurrentDictionary behind the scenes.
+            if (this.httpServerDuration == null)
+            {
+                this.httpServerDuration = this.meter.CreateDoubleMeasure(SemanticConventions.MetricHttpServerDuration);
+            }
+
+            this.httpServerDuration.Record(new SpanContext(activity.Context), activity.Duration.TotalMilliseconds, labels);
+        }
+    }
+}

src/OpenTelemetry.Instrumentation.AspNetCore/MeterProviderBuilderExtensions.cs

@@ -0,0 +1,45 @@
+// <copyright file="MeterProviderBuilderExtensions.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.Metrics
+{
+    /// <summary>
+    /// Extension methods to simplify registering of ASP.NET Core request instrumentation.
+    /// </summary>
+    public static class MeterProviderBuilderExtensions
+    {
+        /// <summary>
+        /// Enables the incoming requests automatic data collection for ASP.NET Core.
+        /// </summary>
+        /// <param name="builder"><see cref="MeterProviderBuilder"/> being configured.</param>
+        /// <returns>The instance of <see cref="MeterProviderBuilder"/> to chain the calls.</returns>
+        public static MeterProviderBuilder AddAspNetCoreInstrumentation(
+            this MeterProviderBuilder builder)
+        {
+            if (builder == null)
+            {
+                throw new ArgumentNullException(nameof(builder));
+            }
+
+            builder.AddInstrumentation((meter) => new AspNetCoreMetrics(meter));
+
+            return builder;
+        }
+    }
+}

src/OpenTelemetry/Metrics/MeterProviderBuilder.cs

@@ -29,6 +29,7 @@ namespace OpenTelemetry.Metrics
     public class MeterProviderBuilder
     {
         private static readonly TimeSpan DefaultPushInterval = TimeSpan.FromSeconds(60);
+        private readonly List<InstrumentationFactory> instrumentationFactories = new List<InstrumentationFactory>();
         private MetricProcessor metricProcessor;
         private MetricExporter metricExporter;
         private TimeSpan metricPushInterval;
@@ -73,6 +74,24 @@ public MeterProviderBuilder SetPushInterval(TimeSpan pushInterval)
             return this;
         }
 
+        public MeterProviderBuilder AddInstrumentation<TInstrumentation>(
+            Func<Meter, TInstrumentation> instrumentationFactory)
+            where TInstrumentation : class
+        {
+            if (instrumentationFactory == null)
+            {
+                throw new ArgumentNullException(nameof(instrumentationFactory));
+            }
+
+            this.instrumentationFactories.Add(
+                new InstrumentationFactory(
+                    typeof(TInstrumentation).Name,
+                    "semver:" + typeof(TInstrumentation).Assembly.GetName().Version,
+                    instrumentationFactory));
+
+            return this;
+        }
+
         public MeterProvider Build()
         {
             var cancellationTokenSource = new CancellationTokenSource();
@@ -85,7 +104,21 @@ public MeterProvider Build()
                 this.metricPushInterval,
                 cancellationTokenSource);
 
-            return new MeterProviderSdk(this.metricProcessor, meterRegistry, controller, cancellationTokenSource);
+            return new MeterProviderSdk(this.metricProcessor, this.instrumentationFactories, meterRegistry, controller, cancellationTokenSource);
+        }
+
+        internal readonly struct InstrumentationFactory
+        {
+            public readonly string Name;
+            public readonly string Version;
+            public readonly Func<Meter, object> Factory;
+
+            internal InstrumentationFactory(string name, string version, Func<Meter, object> factory)
+            {
+                this.Name = name;
+                this.Version = version;
+                this.Factory = factory;
+            }
         }
     }
 }

src/OpenTelemetry/Metrics/MeterProviderSdk.cs

@@ -16,6 +16,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using OpenTelemetry.Metrics.Export;
 
@@ -28,17 +29,32 @@ internal class MeterProviderSdk : MeterProvider
         public CancellationTokenSource CancellationTokenSource;
         public Dictionary<MeterRegistryKey, MeterSdk> MeterRegistry;
 
+        private readonly List<object> instrumentations = new List<object>();
         private readonly object syncObject = new object();
         private MeterSdk defaultMeter;
 
-        internal MeterProviderSdk(MetricProcessor metricProcessor, Dictionary<MeterRegistryKey, MeterSdk> registry, PushMetricController controller, CancellationTokenSource cts)
+        internal MeterProviderSdk(
+            MetricProcessor metricProcessor,
+            IEnumerable<MeterProviderBuilder.InstrumentationFactory> instrumentationFactories,
+            Dictionary<MeterRegistryKey, MeterSdk> registry,
+            PushMetricController controller,
+            CancellationTokenSource cts)
         {
             this.MetricProcessor = metricProcessor;
             this.PushMetricController = controller;
             this.CancellationTokenSource = cts;
             this.defaultMeter = new MeterSdk(string.Empty, this.MetricProcessor);
             this.MeterRegistry = registry;
             this.MeterRegistry.Add(new MeterRegistryKey(string.Empty, null), this.defaultMeter);
+
+            if (instrumentationFactories.Any())
+            {
+                foreach (var instrumentationFactory in instrumentationFactories)
+                {
+                    var meter = Default.GetMeter(instrumentationFactory.Name, instrumentationFactory.Version);
+                    this.instrumentations.Add(instrumentationFactory.Factory(meter));
+                }
+            }
         }
 
         public override Meter GetMeter(string name, string version = null)
@@ -64,6 +80,16 @@ public override Meter GetMeter(string name, string version = null)
 
         protected override void Dispose(bool disposing)
         {
+            if (this.instrumentations != null)
+            {
+                foreach (var item in this.instrumentations)
+                {
+                    (item as IDisposable)?.Dispose();
+                }
+
+                this.instrumentations.Clear();
+            }
+
             this.CancellationTokenSource.Dispose();
 
             // TODO: Actually flush the metric processor/exporer/controllers.