Add request metrics to System.Net.Http

src/libraries/System.Net.Http/ref/System.Net.Http.cs

@@ -214,6 +214,9 @@ public partial class HttpMessageInvoker : System.IDisposable
         public HttpMessageInvoker(System.Net.Http.HttpMessageHandler handler) { }
         public HttpMessageInvoker(System.Net.Http.HttpMessageHandler handler, bool disposeHandler) { }
         public void Dispose() { }
+#pragma warning disable CS3003 // Type is not CLS-compliant
+        public System.Diagnostics.Metrics.Meter Meter { get { throw null; } set { } }
+#pragma warning restore CS3003 // Type is not CLS-compliant
         protected virtual void Dispose(bool disposing) { }
         [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
         public virtual System.Net.Http.HttpResponseMessage Send(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { throw null; }
@@ -263,6 +266,7 @@ public HttpRequestMessage(System.Net.Http.HttpMethod method, System.Uri? request
         [System.ObsoleteAttribute("HttpRequestMessage.Properties has been deprecated. Use Options instead.")]
         public System.Collections.Generic.IDictionary<string, object?> Properties { get { throw null; } }
         public HttpRequestOptions Options { get { throw null; } }
+        public ICollection<KeyValuePair<string, object?>> MetricsTags { get { throw null; } }
         public System.Uri? RequestUri { get { throw null; } set { } }
         public System.Version Version { get { throw null; } set { } }
         public System.Net.Http.HttpVersionPolicy VersionPolicy { get { throw null; } set { } }

src/libraries/System.Net.Http/src/System.Net.Http.csproj

@@ -53,6 +53,7 @@
     <Compile Include="System\Net\Http\HttpMessageHandler.cs" />
     <Compile Include="System\Net\Http\HttpMessageInvoker.cs" />
     <Compile Include="System\Net\Http\HttpMethod.cs" />
+    <Compile Include="System\Net\Http\HttpMetrics.cs" />
     <Compile Include="System\Net\Http\HttpParseResult.cs" />
     <Compile Include="System\Net\Http\HttpProtocolException.cs" />
     <Compile Include="System\Net\Http\HttpRequestException.cs" />

src/libraries/System.Net.Http/src/System/Net/Http/HttpClient.cs

@@ -621,7 +621,7 @@ private void HandleFailure(Exception e, bool telemetryStarted, HttpResponseMessa
                 e = toThrow = CancellationHelper.CreateOperationCanceledException(e, cancellationToken.IsCancellationRequested ? cancellationToken : cts.Token);
             }
 
-            LogRequestFailed(e, telemetryStarted);
+            LogRequestFailed(e, telemetryStarted, out _);
 
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Error(this, e);
 

src/libraries/System.Net.Http/src/System/Net/Http/HttpMessageInvoker.cs

@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Metrics;
 using System.IO;
 using System.Net.Http.Headers;
 using System.Runtime.Versioning;
@@ -14,6 +17,26 @@ public class HttpMessageInvoker : IDisposable
         private volatile bool _disposed;
         private readonly bool _disposeHandler;
         private readonly HttpMessageHandler _handler;
+        private Meter? _meter;
+        private HttpMetrics? _metrics;
+
+#pragma warning disable CS3003 // Type is not CLS-compliant
+        public Meter Meter
+        {
+            // TODO: Should the Meter and HttpMetrics be static and shared by default?
+            get => _meter ??= new Meter("System.Net.Http");
+            set
+            {
+                // TODO: Check that HttpMessageInvoker hasn't been started.
+                ArgumentNullException.ThrowIfNull(value);
+                if (value.Name != "System.Net.Http")
+                {
+                    throw new ArgumentException("Meter name must be 'System.Net.Http'.");
+                }
+                _meter = value;
+            }
+        }
+#pragma warning restore CS3003 // Type is not CLS-compliant
 
         public HttpMessageInvoker(HttpMessageHandler handler)
             : this(handler, true)
@@ -30,31 +53,44 @@ public HttpMessageInvoker(HttpMessageHandler handler, bool disposeHandler)
             _disposeHandler = disposeHandler;
         }
 
+        [MemberNotNull(nameof(_metrics))]
+        private void EnsureMetrics()
+        {
+            _metrics ??= new HttpMetrics(Meter);
+        }
+
         [UnsupportedOSPlatformAttribute("browser")]
         public virtual HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)
         {
             ArgumentNullException.ThrowIfNull(request);
 
             ObjectDisposedException.ThrowIf(_disposed, this);
 
+            EnsureMetrics();
+
             if (ShouldSendWithTelemetry(request))
             {
+                long startTimestamp = Stopwatch.GetTimestamp();
+
                 HttpTelemetry.Log.RequestStart(request);
+                _metrics.RequestStart(request);
 
                 HttpResponseMessage? response = null;
+                Exception? unhandledException = null;
                 try
                 {
                     response = _handler.Send(request, cancellationToken);
                     return response;
                 }
-                catch (Exception ex) when (LogRequestFailed(ex, telemetryStarted: true))
+                catch (Exception ex) when (LogRequestFailed(ex, telemetryStarted: true, out unhandledException))
                 {
                     // Unreachable as LogRequestFailed will return false
                     throw;
                 }
                 finally
                 {
                     HttpTelemetry.Log.RequestStop(response);
+                    _metrics.RequestStop(request, response, unhandledException, startTimestamp, Stopwatch.GetTimestamp());
                 }
             }
             else
@@ -69,47 +105,55 @@ public virtual Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, C
 
             ObjectDisposedException.ThrowIf(_disposed, this);
 
+            EnsureMetrics();
+
             if (ShouldSendWithTelemetry(request))
             {
-                return SendAsyncWithTelemetry(_handler, request, cancellationToken);
+                return SendAsyncWithTelemetry(_handler, request, _metrics, cancellationToken);
             }
 
             return _handler.SendAsync(request, cancellationToken);
 
-            static async Task<HttpResponseMessage> SendAsyncWithTelemetry(HttpMessageHandler handler, HttpRequestMessage request, CancellationToken cancellationToken)
+            static async Task<HttpResponseMessage> SendAsyncWithTelemetry(HttpMessageHandler handler, HttpRequestMessage request, HttpMetrics metrics, CancellationToken cancellationToken)
             {
+                long startTimestamp = Stopwatch.GetTimestamp();
+
                 HttpTelemetry.Log.RequestStart(request);
+                metrics.RequestStart(request);
 
                 HttpResponseMessage? response = null;
+                Exception? unhandledException = null;
                 try
                 {
                     response = await handler.SendAsync(request, cancellationToken).ConfigureAwait(false);
                     return response;
                 }
-                catch (Exception ex) when (LogRequestFailed(ex, telemetryStarted: true))
+                catch (Exception ex) when (LogRequestFailed(ex, telemetryStarted: true, out unhandledException))
                 {
                     // Unreachable as LogRequestFailed will return false
                     throw;
                 }
                 finally
                 {
                     HttpTelemetry.Log.RequestStop(response);
+                    metrics.RequestStop(request, response, unhandledException, startTimestamp, Stopwatch.GetTimestamp());
                 }
             }
         }
 
-        private static bool ShouldSendWithTelemetry(HttpRequestMessage request) =>
-            HttpTelemetry.Log.IsEnabled() &&
+        private bool ShouldSendWithTelemetry(HttpRequestMessage request) =>
+            (HttpTelemetry.Log.IsEnabled() || _metrics!.RequestCountersEnabled()) &&
             !request.WasSentByHttpClient() &&
             request.RequestUri is Uri requestUri &&
             requestUri.IsAbsoluteUri;
 
-        internal static bool LogRequestFailed(Exception exception, bool telemetryStarted)
+        internal static bool LogRequestFailed(Exception exception, bool telemetryStarted, out Exception thrownException)
         {
             if (HttpTelemetry.Log.IsEnabled() && telemetryStarted)
             {
                 HttpTelemetry.Log.RequestFailed(exception);
             }
+            thrownException = exception;
             return false;
         }
 
@@ -124,7 +168,6 @@ protected virtual void Dispose(bool disposing)
             if (disposing && !_disposed)
             {
                 _disposed = true;
-
                 if (_disposeHandler)
                 {
                     _handler.Dispose();

src/libraries/System.Net.Http/src/System/Net/Http/HttpMetrics.cs

@@ -0,0 +1,107 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+
+namespace System.Net.Http
+{
+    internal sealed class HttpMetrics
+    {
+        private readonly Meter _meter;
+        private readonly UpDownCounter<long> _currentRequests;
+        private readonly Histogram<double> _requestsDuration;
+
+        public HttpMetrics(Meter meter)
+        {
+            _meter = meter;
+
+            _currentRequests = _meter.CreateUpDownCounter<long>(
+                "current-requests",
+                description: "Number of outbound HTTP requests that are currently active on the client.");
+
+            _requestsDuration = _meter.CreateHistogram<double>(
+                "request-duration",
+                unit: "s",
+                description: "The duration of outbound HTTP requests.");
+        }
+
+        public void RequestStart(HttpRequestMessage request)
+        {
+            if (_currentRequests.Enabled)
+            {
+                RequestStartCore(request);
+            }
+        }
+
+        public void RequestStartCore(HttpRequestMessage request)
+        {
+#pragma warning disable SA1129 // Do not use default value type constructor
+            var tags = new TagList();
+#pragma warning restore SA1129 // Do not use default value type constructor
+            InitializeCommonTags(ref tags, request);
+
+            _currentRequests.Add(1, tags);
+        }
+
+        public void RequestStop(HttpRequestMessage request, HttpResponseMessage? response, Exception? unhandledException, long startTimestamp, long currentTimestamp)
+        {
+            if (_currentRequests.Enabled || _requestsDuration.Enabled)
+            {
+                RequestStopCore(request, response, unhandledException, startTimestamp, currentTimestamp);
+            }
+        }
+
+        private void RequestStopCore(HttpRequestMessage request, HttpResponseMessage? response, Exception? unhandledException, long startTimestamp, long currentTimestamp)
+        {
+#pragma warning disable SA1129 // Do not use default value type constructor
+            var tags = new TagList();
+#pragma warning restore SA1129 // Do not use default value type constructor
+            InitializeCommonTags(ref tags, request);
+
+            _currentRequests.Add(-1, tags);
+
+            if (response is not null)
+            {
+                tags.Add("status-code", (int)response.StatusCode); // Boxing?
+                tags.Add("protocol", $"HTTP/{response.Version}"); // Hacky
+            }
+            if (unhandledException is not null)
+            {
+                tags.Add("exception-name", unhandledException.GetType().FullName);
+            }
+            if (request.HasTags)
+            {
+                foreach (var customTag in request.MetricsTags)
+                {
+                    tags.Add(customTag);
+                }
+            }
+            var duration = Stopwatch.GetElapsedTime(startTimestamp, currentTimestamp);
+            _requestsDuration.Record(duration.TotalSeconds, tags);
+        }
+
+        private static void InitializeCommonTags(ref TagList tags, HttpRequestMessage request)
+        {
+            if (request.RequestUri is { } requestUri && requestUri.IsAbsoluteUri)
+            {
+                if (requestUri.Scheme is not null)
+                {
+                    tags.Add("scheme", requestUri.Scheme);
+                }
+                if (requestUri.Host is not null)
+                {
+                    tags.Add("host", requestUri.Host);
+                }
+                // Add port tag when not the default value for the current scheme
+                if (!requestUri.IsDefaultPort)
+                {
+                    tags.Add("port", requestUri.Port);
+                }
+            }
+            tags.Add("method", request.Method.Method);
+        }
+
+        internal bool RequestCountersEnabled() => _currentRequests.Enabled || _requestsDuration.Enabled;
+    }
+}

src/libraries/System.Net.Http/src/System/Net/Http/HttpRequestMessage.cs

@@ -31,6 +31,7 @@ public class HttpRequestMessage : IDisposable
         private HttpVersionPolicy _versionPolicy;
         private HttpContent? _content;
         private HttpRequestOptions? _options;
+        private List<KeyValuePair<string, object?>>? _metricsTags;
 
         public Version Version
         {
@@ -116,6 +117,14 @@ public Uri? RequestUri
         /// </summary>
         public HttpRequestOptions Options => _options ??= new HttpRequestOptions();
 
+        // TODO: Should tags be defined in a new collection or stashed in HttpRequestOptions?
+        // If tags are stashed in HttpRequestOptions then there should probably be extension methods to interact with them.
+        // If tags are stored in a collection then a custom collection type might be wanted.
+        // An Add(string name, object? value) method for convenience would be nice.
+        public ICollection<KeyValuePair<string, object?>> MetricsTags => _metricsTags ??= new List<KeyValuePair<string, object?>>();
+
+        internal bool HasTags => _metricsTags != null;
+
         public HttpRequestMessage()
             : this(HttpMethod.Get, (Uri?)null)
         {