[http] Add http.client.request.duration metric and .NET Framework support

src/OpenTelemetry.Instrumentation.Http/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+* Added support for publishing `http.client.duration` metric on .NET Framework
+
 ## 1.5.1-beta.1
 
 Released 2023-Jul-20

src/OpenTelemetry.Instrumentation.Http/Implementation/HttpWebRequestActivitySource.netfx.cs

@@ -17,6 +17,7 @@
 #if NETFRAMEWORK
 using System.Collections;
 using System.Diagnostics;
+using System.Diagnostics.Metrics;
 using System.Net;
 using System.Reflection;
 using System.Reflection.Emit;
@@ -39,12 +40,15 @@ internal static class HttpWebRequestActivitySource
     internal static readonly AssemblyName AssemblyName = typeof(HttpWebRequestActivitySource).Assembly.GetName();
     internal static readonly string ActivitySourceName = AssemblyName.Name + ".HttpWebRequest";
     internal static readonly string ActivityName = ActivitySourceName + ".HttpRequestOut";
+    internal static readonly string MeterInstrumentationName = AssemblyName.Name;
 
     internal static readonly Func<HttpWebRequest, string, IEnumerable<string>> HttpWebRequestHeaderValuesGetter = (request, name) => request.Headers.GetValues(name);
     internal static readonly Action<HttpWebRequest, string, string> HttpWebRequestHeaderValuesSetter = (request, name, value) => request.Headers.Add(name, value);
 
     private static readonly Version Version = AssemblyName.Version;
     private static readonly ActivitySource WebRequestActivitySource = new ActivitySource(ActivitySourceName, Version.ToString());
+    private static readonly Meter WebRequestMeter = new Meter(MeterInstrumentationName, Version.ToString());
+    private static readonly Histogram<double> HttpClientDuration;
 
     private static HttpClientInstrumentationOptions options;
 
@@ -87,6 +91,7 @@ static HttpWebRequestActivitySource()
             PerformInjection();
 
             Options = new HttpClientInstrumentationOptions();
+            HttpClientDuration = WebRequestMeter.CreateHistogram<double>("http.client.duration", "ms", "Measures the duration of outbound HTTP requests.");
         }
         catch (Exception ex)
         {
@@ -157,6 +162,8 @@ private static void AddRequestTagsAndInstrumentRequest(HttpWebRequest request, A
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static void AddResponseTags(HttpWebResponse response, Activity activity)
     {
+        Debug.Assert(activity != null, "Activity must not be null");
+
         if (activity.IsAllDataRequested)
         {
             if (emitOldAttributes)
@@ -185,6 +192,8 @@ private static void AddResponseTags(HttpWebResponse response, Activity activity)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static void AddExceptionTags(Exception exception, Activity activity)
     {
+        Debug.Assert(activity != null, "Activity must not be null");
+
         if (!activity.IsAllDataRequested)
         {
             return;
@@ -265,10 +274,13 @@ private static bool IsRequestInstrumented(HttpWebRequest request)
 
     private static void ProcessRequest(HttpWebRequest request)
     {
-        if (!WebRequestActivitySource.HasListeners() || !Options.EventFilterHttpWebRequest(request))
+        // There are subscribers to the ActivitySource and no user-provided filter is
+        // filtering this request.
+        var enableTracing = WebRequestActivitySource.HasListeners() && Options.EventFilterHttpWebRequest(request);
+
+        if (!enableTracing && !HttpClientDuration.Enabled)
         {
-            // No subscribers to the ActivitySource or User provider Filter is
-            // filtering this request.
+            // Tracing and metrics are not enabled, so we can skip generating signals
             // Propagation must still be done in such cases, to allow
             // downstream services to continue from parent context, if any.
             // Eg: Parent could be the Asp.Net activity.
@@ -283,37 +295,41 @@ private static void ProcessRequest(HttpWebRequest request)
             return;
         }
 
-        var activity = WebRequestActivitySource.StartActivity(ActivityName, ActivityKind.Client);
+        Activity activity = null;
+
+        if (enableTracing)
+        {
+            activity = WebRequestActivitySource.StartActivity(ActivityName, ActivityKind.Client);
+        }
+
         var activityContext = Activity.Current?.Context ?? default;
 
         // Propagation must still be done in all cases, to allow
         // downstream services to continue from parent context, if any.
         // Eg: Parent could be the Asp.Net activity.
         InstrumentRequest(request, activityContext);
-        if (activity == null)
-        {
-            // There is a listener but it decided not to sample the current request.
-            return;
-        }
 
         IAsyncResult asyncContext = writeAResultAccessor(request);
         if (asyncContext != null)
         {
             // Flow here is for [Begin]GetRequestStream[Async].
 
-            AsyncCallbackWrapper callback = new AsyncCallbackWrapper(request, activity, asyncCallbackAccessor(asyncContext));
+            AsyncCallbackWrapper callback = new AsyncCallbackWrapper(request, activity, asyncCallbackAccessor(asyncContext), Stopwatch.GetTimestamp());
             asyncCallbackModifier(asyncContext, callback.AsyncCallback);
         }
         else
         {
             // Flow here is for [Begin]GetResponse[Async] without a prior call to [Begin]GetRequestStream[Async].
 
             asyncContext = readAResultAccessor(request);
-            AsyncCallbackWrapper callback = new AsyncCallbackWrapper(request, activity, asyncCallbackAccessor(asyncContext));
+            AsyncCallbackWrapper callback = new AsyncCallbackWrapper(request, activity, asyncCallbackAccessor(asyncContext), Stopwatch.GetTimestamp());
             asyncCallbackModifier(asyncContext, callback.AsyncCallback);
         }
 
-        AddRequestTagsAndInstrumentRequest(request, activity);
+        if (activity != null)
+        {
+            AddRequestTagsAndInstrumentRequest(request, activity);
+        }
     }
 
     private static void HookOrProcessResult(HttpWebRequest request)
@@ -340,26 +356,32 @@ private static void HookOrProcessResult(HttpWebRequest request)
         if (endCalledAccessor.Invoke(readAsyncContext) || readAsyncContext.CompletedSynchronously)
         {
             // We need to process the result directly because the read callback has already fired. Force a copy because response has likely already been disposed.
-            ProcessResult(readAsyncContext, null, writeAsyncContextCallback.Activity, resultAccessor(readAsyncContext), true);
+            ProcessResult(readAsyncContext, null, writeAsyncContextCallback.Activity, resultAccessor(readAsyncContext), true, request, writeAsyncContextCallback.StartTimestamp);
             return;
         }
 
         // Hook into the result callback if it hasn't already fired.
-        AsyncCallbackWrapper callback = new AsyncCallbackWrapper(writeAsyncContextCallback.Request, writeAsyncContextCallback.Activity, asyncCallbackAccessor(readAsyncContext));
+        AsyncCallbackWrapper callback = new AsyncCallbackWrapper(writeAsyncContextCallback.Request, writeAsyncContextCallback.Activity, asyncCallbackAccessor(readAsyncContext), Stopwatch.GetTimestamp());
         asyncCallbackModifier(readAsyncContext, callback.AsyncCallback);
     }
 
-    private static void ProcessResult(IAsyncResult asyncResult, AsyncCallback asyncCallback, Activity activity, object result, bool forceResponseCopy)
+    private static void ProcessResult(IAsyncResult asyncResult, AsyncCallback asyncCallback, Activity activity, object result, bool forceResponseCopy, HttpWebRequest request, long startTimestamp)
     {
+        HttpStatusCode? httpStatusCode = null;
+
+        // Activity may be null if we are not tracing in these cases:
+        // 1. No listeners
+        // 2. Request was filtered out
+        // 3. Request was not sampled
         // We could be executing on a different thread now so restore the activity if needed.
-        if (Activity.Current != activity)
+        if (activity != null && Activity.Current != activity)
         {
             Activity.Current = activity;
         }
 
         try
         {
-            if (result is Exception ex)
+            if (activity != null && result is Exception ex)
             {
                 AddExceptionTags(ex, activity);
             }
@@ -382,11 +404,21 @@ private static void ProcessResult(IAsyncResult asyncResult, AsyncCallback asyncC
                             isWebSocketResponseAccessor(response), connectionGroupNameAccessor(response),
                         });
 
-                    AddResponseTags(responseCopy, activity);
+                    if (activity != null)
+                    {
+                        AddResponseTags(responseCopy, activity);
+                    }
+
+                    httpStatusCode = responseCopy.StatusCode;
                 }
                 else
                 {
-                    AddResponseTags(response, activity);
+                    if (activity != null)
+                    {
+                        AddResponseTags(response, activity);
+                    }
+
+                    httpStatusCode = response.StatusCode;
                 }
             }
         }
@@ -395,7 +427,37 @@ private static void ProcessResult(IAsyncResult asyncResult, AsyncCallback asyncC
             HttpInstrumentationEventSource.Log.FailedProcessResult(ex);
         }
 
-        activity.Stop();
+        activity?.Stop();
+
+        if (HttpClientDuration.Enabled)
+        {
+            double durationMs = 0;
+
+            if (activity != null)
+            {
+                durationMs = activity.Duration.TotalMilliseconds;
+            }
+            else
+            {
+                var endTimestamp = Stopwatch.GetTimestamp();
+                var durationS = (endTimestamp - startTimestamp) / Stopwatch.Frequency;
+                durationMs = durationS * 1000;
+            }
+
+            TagList tags = default;
+            tags.Add(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocolVersion(request.ProtocolVersion));
+            tags.Add(SemanticConventions.AttributeHttpMethod, request.Method);
+            tags.Add(SemanticConventions.AttributeHttpScheme, request.RequestUri.Scheme);
+            tags.Add(SemanticConventions.AttributeNetPeerName, request.RequestUri.Host);
+            tags.Add(SemanticConventions.AttributeNetPeerPort, request.RequestUri.Port);
+
+            if (httpStatusCode.HasValue)
+            {
+                tags.Add(SemanticConventions.AttributeHttpStatusCode, (int)httpStatusCode.Value);
+            }
+
+            HttpClientDuration.Record(durationMs, tags);
+        }
     }
 
     private static void PrepareReflectionObjects()
@@ -1109,11 +1171,12 @@ public override void Clear()
     /// </summary>
     private sealed class AsyncCallbackWrapper
     {
-        public AsyncCallbackWrapper(HttpWebRequest request, Activity activity, AsyncCallback originalCallback)
+        public AsyncCallbackWrapper(HttpWebRequest request, Activity activity, AsyncCallback originalCallback, long startTimestamp)
         {
             this.Request = request;
             this.Activity = activity;
             this.OriginalCallback = originalCallback;
+            this.StartTimestamp = startTimestamp;
         }
 
         public HttpWebRequest Request { get; }
@@ -1122,12 +1185,21 @@ public AsyncCallbackWrapper(HttpWebRequest request, Activity activity, AsyncCall
 
         public AsyncCallback OriginalCallback { get; }
 
+        public long StartTimestamp { get; }
+
         public void AsyncCallback(IAsyncResult asyncResult)
         {
             object result = resultAccessor(asyncResult);
             if (result is Exception || result is HttpWebResponse)
             {
-                ProcessResult(asyncResult, this.OriginalCallback, this.Activity, result, false);
+                ProcessResult(
+                    asyncResult,
+                    this.OriginalCallback,
+                    this.Activity,
+                    result,
+                    forceResponseCopy: false,
+                    this.Request,
+                    this.StartTimestamp);
             }
 
             this.OriginalCallback?.Invoke(asyncResult);

src/OpenTelemetry.Instrumentation.Http/MeterProviderBuilderExtensions.cs

@@ -14,8 +14,11 @@
 // limitations under the License.
 // </copyright>
 
+#if NETFRAMEWORK
+#else
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
+#endif
 using OpenTelemetry.Instrumentation.Http;
 using OpenTelemetry.Instrumentation.Http.Implementation;
 using OpenTelemetry.Internal;
@@ -52,9 +55,13 @@ public static MeterProviderBuilder AddHttpClientInstrumentation(
         //   Filter - makes sense for metric instrumentation
         //   Enrich - do we want a similar kind of functionality for metrics?
         //   RecordException - probably doesn't make sense for metric instrumentation
-
+#if NETFRAMEWORK
+        builder.AddMeter(HttpWebRequestActivitySource.MeterInstrumentationName);
+#else
         builder.AddMeter(HttpClientMetrics.InstrumentationName);
-        return builder.AddInstrumentation(sp => new HttpClientMetrics(
+        builder.AddInstrumentation(sp => new HttpClientMetrics(
             sp.GetRequiredService<IOptionsMonitor<HttpClientMetricInstrumentationOptions>>().CurrentValue));
+#endif
+        return builder;
     }
 }

src/OpenTelemetry.Instrumentation.Http/README.md

@@ -67,9 +67,6 @@ public class Program
 
 #### Metrics
 
-> **Note**
-> Metrics are not available for .NET Framework.
-
 The following example demonstrates adding `HttpClient` instrumentation with the
 extension method `.AddHttpClientInstrumentation()` on `MeterProviderBuilder` to
 a console application. This example also sets up the OpenTelemetry Console