OWIN HTTP server metrics

src/OpenTelemetry.Instrumentation.Owin/.publicApi/net462/PublicAPI.Unshipped.txt

@@ -9,8 +9,10 @@ OpenTelemetry.Instrumentation.Owin.OwinInstrumentationOptions.Filter.set -> void
 OpenTelemetry.Instrumentation.Owin.OwinInstrumentationOptions.OwinInstrumentationOptions() -> void
 OpenTelemetry.Instrumentation.Owin.OwinInstrumentationOptions.RecordException.get -> bool
 OpenTelemetry.Instrumentation.Owin.OwinInstrumentationOptions.RecordException.set -> void
+OpenTelemetry.Metrics.OwinInstrumentationMeterProviderBuilderExtensions
 OpenTelemetry.Trace.TracerProviderBuilderExtensions
 Owin.AppBuilderExtensions
+static OpenTelemetry.Metrics.OwinInstrumentationMeterProviderBuilderExtensions.AddOwinInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder builder) -> OpenTelemetry.Metrics.MeterProviderBuilder
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddOwinInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder builder) -> OpenTelemetry.Trace.TracerProviderBuilder
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddOwinInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder builder, System.Action<OpenTelemetry.Instrumentation.Owin.OwinInstrumentationOptions> configure) -> OpenTelemetry.Trace.TracerProviderBuilder
 static Owin.AppBuilderExtensions.UseOpenTelemetry(this Owin.IAppBuilder appBuilder) -> Owin.IAppBuilder

src/OpenTelemetry.Instrumentation.Owin/CHANGELOG.md

@@ -6,6 +6,8 @@
   ([#1344](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/1344))
 * Removes `AddOwinInstrumentation` method with default configure parameter.
   ([#929](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/929))
+* Adds HTTP server metrics via `AddOwinInstrumentation` extension method on `MeterProviderBuilder`
+  ([#1335](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/1335))
 
 ## 1.0.0-rc.3
 

src/OpenTelemetry.Instrumentation.Owin/Implementation/DiagnosticsMiddleware.cs

@@ -21,6 +21,7 @@
 using System.Threading.Tasks;
 using Microsoft.Owin;
 using OpenTelemetry.Context.Propagation;
+using OpenTelemetry.Instrumentation.Owin.Implementation;
 using OpenTelemetry.Trace;
 
 namespace OpenTelemetry.Instrumentation.Owin;
@@ -46,15 +47,23 @@ public DiagnosticsMiddleware(OwinMiddleware next)
     /// <inheritdoc />
     public override async Task Invoke(IOwinContext owinContext)
     {
+        long startTimestamp = -1;
+
         try
         {
             BeginRequest(owinContext);
+
+            if (OwinInstrumentationMetrics.HttpServerDuration.Enabled && !owinContext.Environment.ContainsKey(ContextKey))
+            {
+                startTimestamp = Stopwatch.GetTimestamp();
+            }
+
             await this.Next.Invoke(owinContext).ConfigureAwait(false);
-            RequestEnd(owinContext, null);
+            RequestEnd(owinContext, null, startTimestamp);
         }
         catch (Exception ex)
         {
-            RequestEnd(owinContext, ex);
+            RequestEnd(owinContext, ex, startTimestamp);
             throw;
         }
     }
@@ -151,7 +160,7 @@ private static void BeginRequest(IOwinContext owinContext)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void RequestEnd(IOwinContext owinContext, Exception exception)
+    private static void RequestEnd(IOwinContext owinContext, Exception exception, long startTimestamp)
     {
         if (owinContext.Environment.TryGetValue(ContextKey, out object context)
             && context is Activity activity)
@@ -199,11 +208,32 @@ private static void RequestEnd(IOwinContext owinContext, Exception exception)
 
             activity.Stop();
 
+            if (OwinInstrumentationMetrics.HttpServerDuration.Enabled)
+            {
+                OwinInstrumentationMetrics.HttpServerDuration.Record(
+                    activity.Duration.TotalSeconds,
+                    new(SemanticConventions.AttributeHttpRequestMethod, owinContext.Request.Method),
+                    new(SemanticConventions.AttributeUrlScheme, owinContext.Request.Scheme),
+                    new(SemanticConventions.AttributeHttpResponseStatusCode, owinContext.Response.StatusCode));
+            }
+
             if (!(Propagators.DefaultTextMapPropagator is TraceContextPropagator))
             {
                 Baggage.Current = default;
             }
         }
+        else if (OwinInstrumentationMetrics.HttpServerDuration.Enabled)
+        {
+            var endTimestamp = Stopwatch.GetTimestamp();
+            var duration = endTimestamp - startTimestamp;
+            var durationS = duration / Stopwatch.Frequency;
+
+            OwinInstrumentationMetrics.HttpServerDuration.Record(
+                durationS,
+                new(SemanticConventions.AttributeHttpRequestMethod, owinContext.Request.Method),
+                new(SemanticConventions.AttributeUrlScheme, owinContext.Request.Scheme),
+                new(SemanticConventions.AttributeHttpResponseStatusCode, owinContext.Response.StatusCode));
+        }
     }
 
     /// <summary>

src/OpenTelemetry.Instrumentation.Owin/Implementation/OwinInstrumentationMetrics.cs

@@ -0,0 +1,31 @@
+// <copyright file="OwinInstrumentationMetrics.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.Diagnostics.Metrics;
+using System.Reflection;
+
+namespace OpenTelemetry.Instrumentation.Owin.Implementation;
+
+internal static class OwinInstrumentationMetrics
+{
+    internal static readonly AssemblyName AssemblyName = typeof(OwinInstrumentationMetrics).Assembly.GetName();
+
+    public static string MeterName => AssemblyName.Name;
+
+    public static Meter Instance => new Meter(MeterName, AssemblyName.Version.ToString());
+
+    public static Histogram<double> HttpServerDuration => Instance.CreateHistogram<double>("http.server.request.duration", "s", "Measures the duration of inbound HTTP requests.");
+}

src/OpenTelemetry.Instrumentation.Owin/OwinInstrumentationMeterProviderBuilderExtensions.cs

@@ -0,0 +1,40 @@
+// <copyright file="OwinInstrumentationMeterProviderBuilderExtensions.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 OpenTelemetry.Instrumentation.Owin.Implementation;
+using OpenTelemetry.Internal;
+
+namespace OpenTelemetry.Metrics;
+
+/// <summary>
+/// Extension methods to simplify registering of OWIN request instrumentation.
+/// </summary>
+public static class OwinInstrumentationMeterProviderBuilderExtensions
+{
+    /// <summary>
+    /// Enables the incoming requests automatic data collection for OWIN.
+    /// </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 AddOwinInstrumentation(
+        this MeterProviderBuilder builder)
+    {
+        Guard.ThrowIfNull(builder);
+
+        builder.AddMeter(OwinInstrumentationMetrics.MeterName);
+        return builder;
+    }
+}

src/Shared/SemanticConventions.cs

@@ -108,5 +108,11 @@ internal static class SemanticConventions
     public const string AttributeExceptionType = "exception.type";
     public const string AttributeExceptionMessage = "exception.message";
     public const string AttributeExceptionStacktrace = "exception.stacktrace";
+
+    // v1.21.0
+    // https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/http/http-metrics.md#http-server
+    public const string AttributeHttpRequestMethod = "http.request.method"; // replaces: "http.method" (AttributeHttpMethod)
+    public const string AttributeHttpResponseStatusCode = "http.response.status_code"; // replaces: "http.status_code" (AttributeHttpStatusCode)
+    public const string AttributeUrlScheme = "url.scheme"; // replaces: "http.scheme" (AttributeHttpScheme)
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
 }

test/OpenTelemetry.Instrumentation.Owin.Tests/DiagnosticsMiddlewareTests.cs

@@ -24,6 +24,8 @@
 using System.Web.Http;
 using Microsoft.Owin;
 using Microsoft.Owin.Hosting;
+using OpenTelemetry.Instrumentation.Owin.Implementation;
+using OpenTelemetry.Metrics;
 using OpenTelemetry.Trace;
 using Owin;
 using Xunit;
@@ -106,27 +108,43 @@ public void Dispose()
     }
 
     [Theory]
-    [InlineData(true, false)]
-    [InlineData(true, true)]
-    [InlineData(false)]
+    [InlineData(true, false, false)]
     [InlineData(true, false, true)]
-    [InlineData(true, false, true, true)]
-    [InlineData(true, false, false, false, true)]
-    [InlineData(true, false, false, false, true, true)]
+    [InlineData(true, false, false, true)]
+    [InlineData(true, false, false, true, true)]
+    [InlineData(true, false, false, false, false, true)]
+    [InlineData(true, false, false, false, false, true, true)]
+    [InlineData(true, true, false)]
+    [InlineData(true, true, true)]
+    [InlineData(true, true, false, true)]
+    [InlineData(true, true, false, true, true)]
+    [InlineData(true, true, false, false, false, true)]
+    [InlineData(true, true, false, false, false, true, true)]
+    [InlineData(false, true, false)]
+    [InlineData(false, true, true)]
+    [InlineData(false, true, false, true)]
+    [InlineData(false, true, false, true, true)]
+    [InlineData(false, true, false, false, false, true)]
+    [InlineData(false, true, false, false, false, true, true)]
+    [InlineData(false, false)]
     public async Task OutgoingRequestInstrumentationTest(
-        bool instrument,
+        bool instrumentTraces,
+        bool instrumentMetrics,
         bool filter = false,
         bool enrich = false,
         bool enrichmentException = false,
         bool generateRemoteException = false,
         bool recordException = false)
     {
         List<Activity> stoppedActivities = new List<Activity>();
+        List<Metric> exportedMetrics = new List<Metric>();
 
         var builder = Sdk.CreateTracerProviderBuilder()
             .AddInMemoryExporter(stoppedActivities);
+        var meterBuilder = Sdk.CreateMeterProviderBuilder()
+            .AddInMemoryExporter(exportedMetrics);
 
-        if (instrument)
+        if (instrumentTraces)
         {
             builder
                 .AddOwinInstrumentation(options =>
@@ -159,7 +177,13 @@ public async Task OutgoingRequestInstrumentationTest(
                 });
         }
 
+        if (instrumentMetrics)
+        {
+            meterBuilder.AddOwinInstrumentation();
+        }
+
         using TracerProvider tracerProvider = builder.Build();
+        using MeterProvider meterProvider = meterBuilder.Build();
 
         using HttpClient client = new HttpClient();
 
@@ -177,7 +201,7 @@ Owin has finished to inspect the activity status. */
 
         Assert.True(this.requestCompleteHandle.WaitOne(3000));
 
-        if (instrument)
+        if (instrumentTraces)
         {
             if (!filter)
             {
@@ -222,5 +246,63 @@ Owin has finished to inspect the activity status. */
         {
             Assert.Empty(stoppedActivities);
         }
+
+        if (instrumentMetrics)
+        {
+            meterProvider.Dispose();
+            var metric = exportedMetrics[0];
+            var metricPoints = this.GetMetricPoints(metric);
+            var metricPoint = Assert.Single(metricPoints);
+
+            Assert.Equal(OwinInstrumentationMetrics.MeterName, metric.MeterName);
+            Assert.Equal("http.server.request.duration", metric.Name);
+            Assert.Equal(MetricType.Histogram, metric.MetricType);
+            Assert.Equal(1, metricPoint.GetHistogramCount());
+            Assert.Equal(3, metricPoint.Tags.Count);
+
+            foreach (var tag in metricPoint.Tags)
+            {
+                switch (tag.Key)
+                {
+                    case SemanticConventions.AttributeHttpMethod:
+                        Assert.Equal("GET", tag.Value);
+                        break;
+                    case SemanticConventions.AttributeHttpScheme:
+                        Assert.Equal(requestUri.Scheme, tag.Value);
+                        break;
+                    case SemanticConventions.AttributeHttpStatusCode:
+                        Assert.Equal(generateRemoteException ? 500 : 200, tag.Value);
+                        break;
+                }
+            }
+        }
+        else
+        {
+            Assert.Empty(exportedMetrics);
+        }
+
+        if (instrumentMetrics && instrumentTraces && !filter)
+        {
+            var metric = Assert.Single(exportedMetrics);
+            var activity = Assert.Single(stoppedActivities);
+            var metricPoints = this.GetMetricPoints(metric);
+            var metricPoint = Assert.Single(metricPoints);
+
+            // metric value and span duration should match
+            // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-metrics.md#metric-httpserverrequestduration
+            Assert.Equal(activity.Duration.TotalMilliseconds, metricPoint.GetHistogramSum());
+        }
+    }
+
+    private List<MetricPoint> GetMetricPoints(Metric metric)
+    {
+        List<MetricPoint> metricPoints = new();
+
+        foreach (var metricPoint in metric.GetMetricPoints())
+        {
+            metricPoints.Add(metricPoint);
+        }
+
+        return metricPoints;
     }
 }