Add SocketsHttpHandler requests-queue-duration metrics (#88981)

MihaZupan · web-flow · commit 9ffdb53540ce · 2023-07-17T10:21:26.000-07:00
* Add SocketsHttpHandler requests-queue-duration metrics

* Use the IsDefaultPort helper in more places

* PR feedback

* Simplify queueStartingTimestamp logic in Http3Connection
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/HttpTelemetry.AnyOS.cs b/src/libraries/System.Net.Http/src/System/Net/Http/HttpTelemetry.AnyOS.cs
@@ -1,6 +1,7 @@
 ﻿// 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.Tracing;
 using System.Threading;
 
@@ -21,24 +22,22 @@ internal sealed partial class HttpTelemetry
         private EventCounter? _http30RequestsQueueDurationCounter;
 
         [NonEvent]
-        public void Http11RequestLeftQueue(double timeOnQueueMilliseconds)
+        public void RequestLeftQueue(int versionMajor, TimeSpan duration)
         {
-            _http11RequestsQueueDurationCounter?.WriteMetric(timeOnQueueMilliseconds);
-            RequestLeftQueue(timeOnQueueMilliseconds, versionMajor: 1, versionMinor: 1);
-        }
+            Debug.Assert(versionMajor is 1 or 2 or 3);
 
-        [NonEvent]
-        public void Http20RequestLeftQueue(double timeOnQueueMilliseconds)
-        {
-            _http20RequestsQueueDurationCounter?.WriteMetric(timeOnQueueMilliseconds);
-            RequestLeftQueue(timeOnQueueMilliseconds, versionMajor: 2, versionMinor: 0);
-        }
+            EventCounter? counter = versionMajor switch
+            {
+                1 => _http11RequestsQueueDurationCounter,
+                2 => _http20RequestsQueueDurationCounter,
+                _ => _http30RequestsQueueDurationCounter
+            };
 
-        [NonEvent]
-        public void Http30RequestLeftQueue(double timeOnQueueMilliseconds)
-        {
-            _http30RequestsQueueDurationCounter?.WriteMetric(timeOnQueueMilliseconds);
-            RequestLeftQueue(timeOnQueueMilliseconds, versionMajor: 3, versionMinor: 0);
+            double timeOnQueueMs = duration.TotalMilliseconds;
+
+            counter?.WriteMetric(timeOnQueueMs);
+
+            RequestLeftQueue(timeOnQueueMs, (byte)versionMajor, versionMinor: versionMajor == 1 ? (byte)1 : (byte)0);
         }
 
         protected override void OnEventCommand(EventCommandEventArgs command)
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3Connection.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3Connection.cs
@@ -173,11 +173,6 @@ public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, lon
                     QuicConnection? conn = _connection;
                     if (conn != null)
                     {
-                        if (HttpTelemetry.Log.IsEnabled() && queueStartingTimestamp == 0)
-                        {
-                            queueStartingTimestamp = Stopwatch.GetTimestamp();
-                        }
-
                         quicStream = await conn.OpenOutboundStreamAsync(QuicStreamType.Bidirectional, cancellationToken).ConfigureAwait(false);
 
                         requestStream = new Http3RequestStream(request, this, quicStream);
@@ -198,9 +193,16 @@ public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, lon
                 catch (QuicException e) when (e.QuicError != QuicError.OperationAborted) { }
                 finally
                 {
-                    if (HttpTelemetry.Log.IsEnabled() && queueStartingTimestamp != 0)
+                    if (queueStartingTimestamp != 0)
                     {
-                        HttpTelemetry.Log.Http30RequestLeftQueue(Stopwatch.GetElapsedTime(queueStartingTimestamp).TotalMilliseconds);
+                        TimeSpan duration = Stopwatch.GetElapsedTime(queueStartingTimestamp);
+
+                        _pool.Settings._metrics!.RequestLeftQueue(Pool, duration, versionMajor: 3);
+
+                        if (HttpTelemetry.Log.IsEnabled())
+                        {
+                            HttpTelemetry.Log.RequestLeftQueue(versionMajor: 3, duration);
+                        }
                     }
                 }
 
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionBase.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionBase.cs
@@ -42,20 +42,18 @@ public HttpConnectionBase(HttpConnectionPool pool)
                 metrics.IdleConnections.Enabled ||
                 metrics.ConnectionDuration.Enabled)
             {
+                // While requests may report HTTP/1.0 as the protocol, we treat all HTTP/1.X connections as HTTP/1.1.
                 string protocol =
                     this is HttpConnection ? "HTTP/1.1" :
                     this is Http2Connection ? "HTTP/2" :
                     "HTTP/3";
 
-                int port = pool.OriginAuthority.Port;
-                int defaultPort = pool.IsSecure ? HttpConnectionPool.DefaultHttpsPort : HttpConnectionPool.DefaultHttpPort;
-
                 _connectionMetrics = new ConnectionMetrics(
                     metrics,
                     protocol,
                     pool.IsSecure ? "https" : "http",
                     pool.OriginAuthority.HostValue,
-                    port == defaultPort ? null : port);
+                    pool.IsDefaultPort ? null : pool.OriginAuthority.Port);
 
                 _connectionMetrics.ConnectionEstablished();
 
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs
@@ -236,10 +236,9 @@ public HttpConnectionPool(HttpConnectionPoolManager poolManager, HttpConnectionK
             {
                 // Precalculate ASCII bytes for Host header
                 // Note that if _host is null, this is a (non-tunneled) proxy connection, and we can't cache the hostname.
-                hostHeader =
-                    (_originAuthority.Port != (sslHostName == null ? DefaultHttpPort : DefaultHttpsPort)) ?
-                    $"{_originAuthority.HostValue}:{_originAuthority.Port}" :
-                    _originAuthority.HostValue;
+                hostHeader = IsDefaultPort
+                    ? _originAuthority.HostValue
+                    : $"{_originAuthority.HostValue}:{_originAuthority.Port}";
 
                 // Note the IDN hostname should always be ASCII, since it's already been IDNA encoded.
                 byte[] hostHeaderLine = new byte[6 + hostHeader.Length + 2]; // Host: foo\r\n
@@ -363,6 +362,7 @@ private static SslClientAuthenticationOptions ConstructSslOptions(HttpConnection
         public ICredentials? ProxyCredentials => _poolManager.ProxyCredentials;
         public byte[]? HostHeaderLineBytes => _hostHeaderLineBytes;
         public CredentialCache? PreAuthCredentials { get; }
+        public bool IsDefaultPort => OriginAuthority.Port == (IsSecure ? DefaultHttpsPort : DefaultHttpPort);
 
         /// <summary>
         /// An ASCII origin string per RFC 6454 Section 6.2, in format &lt;scheme&gt;://&lt;host&gt;[:&lt;port&gt;]
@@ -381,7 +381,7 @@ public byte[] Http2AltSvcOriginUri
                     sb.Append(IsSecure ? "https://" : "http://")
                       .Append(_originAuthority.IdnHost);
 
-                    if (_originAuthority.Port != (IsSecure ? DefaultHttpsPort : DefaultHttpPort))
+                    if (!IsDefaultPort)
                     {
                         sb.Append(CultureInfo.InvariantCulture, $":{_originAuthority.Port}");
                     }
@@ -998,16 +998,10 @@ private async ValueTask<Http3Connection> GetHttp3ConnectionAsync(HttpRequestMess
                     ThrowGetVersionException(request, 3, reasonException);
                 }
 
-                long queueStartingTimestamp = HttpTelemetry.Log.IsEnabled() ? Stopwatch.GetTimestamp() : 0;
+                long queueStartingTimestamp = HttpTelemetry.Log.IsEnabled() || Settings._metrics!.RequestsQueueDuration.Enabled ? Stopwatch.GetTimestamp() : 0;
 
                 ValueTask<Http3Connection> connectionTask = GetHttp3ConnectionAsync(request, authority, cancellationToken);
 
-                if (HttpTelemetry.Log.IsEnabled() && connectionTask.IsCompleted)
-                {
-                    // We avoid logging RequestLeftQueue if a stream was available immediately (synchronously)
-                    queueStartingTimestamp = 0;
-                }
-
                 Http3Connection connection = await connectionTask.ConfigureAwait(false);
 
                 HttpResponseMessage response = await connection.SendAsync(request, queueStartingTimestamp, cancellationToken).ConfigureAwait(false);
@@ -1089,7 +1083,7 @@ public async ValueTask<HttpResponseMessage> SendWithVersionDetectionAndRetryAsyn
                             if (!TryGetPooledHttp2Connection(request, out Http2Connection? connection, out http2ConnectionWaiter) &&
                                 http2ConnectionWaiter != null)
                             {
-                                connection = await http2ConnectionWaiter.WaitForConnectionAsync(async, cancellationToken).ConfigureAwait(false);
+                                connection = await http2ConnectionWaiter.WaitForConnectionAsync(this, async, cancellationToken).ConfigureAwait(false);
                             }
 
                             Debug.Assert(connection is not null || !_http2Enabled);
@@ -1121,7 +1115,7 @@ public async ValueTask<HttpResponseMessage> SendWithVersionDetectionAndRetryAsyn
                             // Use HTTP/1.x.
                             if (!TryGetPooledHttp11Connection(request, async, out HttpConnection? connection, out http11ConnectionWaiter))
                             {
-                                connection = await http11ConnectionWaiter.WaitForConnectionAsync(async, cancellationToken).ConfigureAwait(false);
+                                connection = await http11ConnectionWaiter.WaitForConnectionAsync(this, async, cancellationToken).ConfigureAwait(false);
                             }
 
                             connection.Acquire(); // In case we are doing Windows (i.e. connection-based) auth, we need to ensure that we hold on to this specific connection while auth is underway.
@@ -1199,6 +1193,7 @@ public async ValueTask<HttpResponseMessage> SendWithVersionDetectionAndRetryAsyn
         }
 
         private void CancelIfNecessary<T>(HttpConnectionWaiter<T>? waiter, bool requestCancelled)
+            where T : HttpConnectionBase?
         {
             int timeout = GlobalHttpSettings.SocketsHttpHandler.PendingConnectionTimeoutOnRequestCompletion;
             if (waiter?.ConnectionCancellationTokenSource is null ||
@@ -2430,6 +2425,7 @@ private void Trace(string? message, [CallerMemberName] string? memberName = null
                 message);                    // message
 
         private struct RequestQueue<T>
+            where T : HttpConnectionBase?
         {
             public struct QueueItem
             {
@@ -2599,6 +2595,7 @@ public QueueItem PeekNextRequestForConnectionAttempt()
         }
 
         private sealed class HttpConnectionWaiter<T> : TaskCompletionSourceWithCancellation<T>
+            where T : HttpConnectionBase?
         {
             // When a connection attempt is pending, reference the connection's CTS, so we can tear it down if the initiating request is cancelled
             // or completes on a different connection.
@@ -2607,21 +2604,32 @@ private sealed class HttpConnectionWaiter<T> : TaskCompletionSourceWithCancellat
             // Distinguish connection cancellation that happens because the initiating request is cancelled or completed on a different connection.
             public bool CancelledByOriginatingRequestCompletion { get; set; }
 
-            public async ValueTask<T> WaitForConnectionAsync(bool async, CancellationToken requestCancellationToken)
+            public ValueTask<T> WaitForConnectionAsync(HttpConnectionPool pool, bool async, CancellationToken requestCancellationToken)
             {
+                return HttpTelemetry.Log.IsEnabled() || pool.Settings._metrics!.RequestsQueueDuration.Enabled
+                    ? WaitForConnectionWithTelemetryAsync(pool, async, requestCancellationToken)
+                    : WaitWithCancellationAsync(async, requestCancellationToken);
+            }
+
+            private async ValueTask<T> WaitForConnectionWithTelemetryAsync(HttpConnectionPool pool, bool async, CancellationToken requestCancellationToken)
+            {
+                Debug.Assert(typeof(T) == typeof(HttpConnection) || typeof(T) == typeof(Http2Connection));
+
                 long startingTimestamp = Stopwatch.GetTimestamp();
                 try
                 {
                     return await WaitWithCancellationAsync(async, requestCancellationToken).ConfigureAwait(false);
                 }
                 finally
                 {
+                    TimeSpan duration = Stopwatch.GetElapsedTime(startingTimestamp);
+                    int versionMajor = typeof(T) == typeof(HttpConnection) ? 1 : 2;
+
+                    pool.Settings._metrics!.RequestLeftQueue(pool, duration, versionMajor);
+
                     if (HttpTelemetry.Log.IsEnabled())
                     {
-                        if (typeof(T) == typeof(HttpConnection))
-                            HttpTelemetry.Log.Http11RequestLeftQueue(Stopwatch.GetElapsedTime(startingTimestamp).TotalMilliseconds);
-                        else if (typeof(T) == typeof(Http2Connection))
-                            HttpTelemetry.Log.Http20RequestLeftQueue(Stopwatch.GetElapsedTime(startingTimestamp).TotalMilliseconds);
+                        HttpTelemetry.Log.RequestLeftQueue(versionMajor, duration);
                     }
                 }
             }
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Metrics/SocketsHttpHandlerMetrics.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Metrics/SocketsHttpHandlerMetrics.cs
@@ -1,6 +1,7 @@
 ﻿// 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.Metrics
@@ -19,5 +20,38 @@ internal sealed class SocketsHttpHandlerMetrics(Meter meter)
             name: "http-client-connection-duration",
             unit: "s",
             description: "The duration of outbound HTTP connections.");
+
+        public readonly Histogram<double> RequestsQueueDuration = meter.CreateHistogram<double>(
+            name: "http-client-requests-queue-duration",
+            unit: "s",
+            description: "The amount of time requests spent on a queue waiting for an available connection.");
+
+        public void RequestLeftQueue(HttpConnectionPool pool, TimeSpan duration, int versionMajor)
+        {
+            Debug.Assert(versionMajor is 1 or 2 or 3);
+
+            if (RequestsQueueDuration.Enabled)
+            {
+                TagList tags = default;
+
+                // While requests may report HTTP/1.0 as the protocol, we treat all HTTP/1.X connections as HTTP/1.1.
+                tags.Add("protocol", versionMajor switch
+                {
+                    1 => "HTTP/1.1",
+                    2 => "HTTP/2",
+                    _ => "HTTP/3"
+                });
+
+                tags.Add("scheme", pool.IsSecure ? "https" : "http");
+                tags.Add("host", pool.OriginAuthority.HostValue);
+
+                if (!pool.IsDefaultPort)
+                {
+                    tags.Add("port", pool.OriginAuthority.Port);
+                }
+
+                RequestsQueueDuration.Record(duration.TotalSeconds, tags);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/MetricsTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/MetricsTest.cs

Original file line number	Diff line number	Diff line change
`@@ -173,11 +173,6 @@ public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, lon`
`173`	`173`	`QuicConnection? conn = _connection;`
`174`	`174`	`if (conn != null)`
`175`	`175`	`{`
`176`		`- if (HttpTelemetry.Log.IsEnabled() && queueStartingTimestamp == 0)`
`177`		`- {`
`178`		`- queueStartingTimestamp = Stopwatch.GetTimestamp();`
`179`		`- }`
`180`		`-`
`181`	`176`	`quicStream = await conn.OpenOutboundStreamAsync(QuicStreamType.Bidirectional, cancellationToken).ConfigureAwait(false);`
`182`	`177`
`183`	`178`	`requestStream = new Http3RequestStream(request, this, quicStream);`
`@@ -198,9 +193,16 @@ public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, lon`
`198`	`193`	`catch (QuicException e) when (e.QuicError != QuicError.OperationAborted) { }`
`199`	`194`	`finally`
`200`	`195`	`{`
`201`		`- if (HttpTelemetry.Log.IsEnabled() && queueStartingTimestamp != 0)`
	`196`	`+ if (queueStartingTimestamp != 0)`
`202`	`197`	`{`
`203`		`- HttpTelemetry.Log.Http30RequestLeftQueue(Stopwatch.GetElapsedTime(queueStartingTimestamp).TotalMilliseconds);`
	`198`	`+ TimeSpan duration = Stopwatch.GetElapsedTime(queueStartingTimestamp);`
	`199`	`+`
	`200`	`+ _pool.Settings._metrics!.RequestLeftQueue(Pool, duration, versionMajor: 3);`
	`201`	`+`
	`202`	`+ if (HttpTelemetry.Log.IsEnabled())`
	`203`	`+ {`
	`204`	`+ HttpTelemetry.Log.RequestLeftQueue(versionMajor: 3, duration);`
	`205`	`+ }`
`204`	`206`	`}`
`205`	`207`	`}`
`206`	`208`
Original file line number	Diff line number	Diff line change
`@@ -236,10 +236,9 @@ public HttpConnectionPool(HttpConnectionPoolManager poolManager, HttpConnectionK`
`236`	`236`	`{`
`237`	`237`	`// Precalculate ASCII bytes for Host header`
`238`	`238`	`// Note that if _host is null, this is a (non-tunneled) proxy connection, and we can't cache the hostname.`
`239`		`- hostHeader =`
`240`		`- (_originAuthority.Port != (sslHostName == null ? DefaultHttpPort : DefaultHttpsPort)) ?`
`241`		`- $"{_originAuthority.HostValue}:{_originAuthority.Port}" :`
`242`		`- _originAuthority.HostValue;`
	`239`	`+ hostHeader = IsDefaultPort`
	`240`	`+ ? _originAuthority.HostValue`
	`241`	`+ : $"{_originAuthority.HostValue}:{_originAuthority.Port}";`
`243`	`242`
`244`	`243`	`// Note the IDN hostname should always be ASCII, since it's already been IDNA encoded.`
`245`	`244`	`byte[] hostHeaderLine = new byte[6 + hostHeader.Length + 2]; // Host: foo\r\n`
`@@ -363,6 +362,7 @@ private static SslClientAuthenticationOptions ConstructSslOptions(HttpConnection`
`363`	`362`	`public ICredentials? ProxyCredentials => _poolManager.ProxyCredentials;`
`364`	`363`	`public byte[]? HostHeaderLineBytes => _hostHeaderLineBytes;`
`365`	`364`	`public CredentialCache? PreAuthCredentials { get; }`
	`365`	`+ public bool IsDefaultPort => OriginAuthority.Port == (IsSecure ? DefaultHttpsPort : DefaultHttpPort);`
`366`	`366`
`367`	`367`	`/// <summary>`
`368`	`368`	`/// An ASCII origin string per RFC 6454 Section 6.2, in format <scheme>://<host>[:<port>]`
`@@ -381,7 +381,7 @@ public byte[] Http2AltSvcOriginUri`
`381`	`381`	`sb.Append(IsSecure ? "https://" : "http://")`
`382`	`382`	`.Append(_originAuthority.IdnHost);`
`383`	`383`
`384`		`- if (_originAuthority.Port != (IsSecure ? DefaultHttpsPort : DefaultHttpPort))`
	`384`	`+ if (!IsDefaultPort)`
`385`	`385`	`{`
`386`	`386`	`sb.Append(CultureInfo.InvariantCulture, $":{_originAuthority.Port}");`
`387`	`387`	`}`
`@@ -998,16 +998,10 @@ private async ValueTask<Http3Connection> GetHttp3ConnectionAsync(HttpRequestMess`
`998`	`998`	`ThrowGetVersionException(request, 3, reasonException);`
`999`	`999`	`}`
`1000`	`1000`
`1001`		`- long queueStartingTimestamp = HttpTelemetry.Log.IsEnabled() ? Stopwatch.GetTimestamp() : 0;`
	`1001`	`+ long queueStartingTimestamp = HttpTelemetry.Log.IsEnabled() \|\| Settings._metrics!.RequestsQueueDuration.Enabled ? Stopwatch.GetTimestamp() : 0;`
`1002`	`1002`
`1003`	`1003`	`ValueTask<Http3Connection> connectionTask = GetHttp3ConnectionAsync(request, authority, cancellationToken);`
`1004`	`1004`
`1005`		`- if (HttpTelemetry.Log.IsEnabled() && connectionTask.IsCompleted)`
`1006`		`- {`
`1007`		`- // We avoid logging RequestLeftQueue if a stream was available immediately (synchronously)`
`1008`		`- queueStartingTimestamp = 0;`
`1009`		`- }`
`1010`		`-`
`1011`	`1005`	`Http3Connection connection = await connectionTask.ConfigureAwait(false);`
`1012`	`1006`
`1013`	`1007`	`HttpResponseMessage response = await connection.SendAsync(request, queueStartingTimestamp, cancellationToken).ConfigureAwait(false);`
`@@ -1089,7 +1083,7 @@ public async ValueTask<HttpResponseMessage> SendWithVersionDetectionAndRetryAsyn`
`1089`	`1083`	`if (!TryGetPooledHttp2Connection(request, out Http2Connection? connection, out http2ConnectionWaiter) &&`
`1090`	`1084`	`http2ConnectionWaiter != null)`
`1091`	`1085`	`{`
`1092`		`- connection = await http2ConnectionWaiter.WaitForConnectionAsync(async, cancellationToken).ConfigureAwait(false);`
	`1086`	`+ connection = await http2ConnectionWaiter.WaitForConnectionAsync(this, async, cancellationToken).ConfigureAwait(false);`
`1093`	`1087`	`}`
`1094`	`1088`
`1095`	`1089`	`Debug.Assert(connection is not null \|\| !_http2Enabled);`
`@@ -1121,7 +1115,7 @@ public async ValueTask<HttpResponseMessage> SendWithVersionDetectionAndRetryAsyn`
`1121`	`1115`	`// Use HTTP/1.x.`
`1122`	`1116`	`if (!TryGetPooledHttp11Connection(request, async, out HttpConnection? connection, out http11ConnectionWaiter))`
`1123`	`1117`	`{`
`1124`		`- connection = await http11ConnectionWaiter.WaitForConnectionAsync(async, cancellationToken).ConfigureAwait(false);`
	`1118`	`+ connection = await http11ConnectionWaiter.WaitForConnectionAsync(this, async, cancellationToken).ConfigureAwait(false);`
`1125`	`1119`	`}`
`1126`	`1120`
`1127`	`1121`	`connection.Acquire(); // In case we are doing Windows (i.e. connection-based) auth, we need to ensure that we hold on to this specific connection while auth is underway.`
`@@ -1199,6 +1193,7 @@ public async ValueTask<HttpResponseMessage> SendWithVersionDetectionAndRetryAsyn`
`1199`	`1193`	`}`
`1200`	`1194`
`1201`	`1195`	`private void CancelIfNecessary<T>(HttpConnectionWaiter<T>? waiter, bool requestCancelled)`
	`1196`	`+ where T : HttpConnectionBase?`
`1202`	`1197`	`{`
`1203`	`1198`	`int timeout = GlobalHttpSettings.SocketsHttpHandler.PendingConnectionTimeoutOnRequestCompletion;`
`1204`	`1199`	`if (waiter?.ConnectionCancellationTokenSource is null \|\|`
`@@ -2430,6 +2425,7 @@ private void Trace(string? message, [CallerMemberName] string? memberName = null`
`2430`	`2425`	`message); // message`
`2431`	`2426`
`2432`	`2427`	`private struct RequestQueue<T>`
	`2428`	`+ where T : HttpConnectionBase?`
`2433`	`2429`	`{`
`2434`	`2430`	`public struct QueueItem`
`2435`	`2431`	`{`
`@@ -2599,6 +2595,7 @@ public QueueItem PeekNextRequestForConnectionAttempt()`
`2599`	`2595`	`}`
`2600`	`2596`
`2601`	`2597`	`private sealed class HttpConnectionWaiter<T> : TaskCompletionSourceWithCancellation<T>`
	`2598`	`+ where T : HttpConnectionBase?`
`2602`	`2599`	`{`
`2603`	`2600`	`// When a connection attempt is pending, reference the connection's CTS, so we can tear it down if the initiating request is cancelled`
`2604`	`2601`	`// or completes on a different connection.`
`@@ -2607,21 +2604,32 @@ private sealed class HttpConnectionWaiter<T> : TaskCompletionSourceWithCancellat`
`2607`	`2604`	`// Distinguish connection cancellation that happens because the initiating request is cancelled or completed on a different connection.`
`2608`	`2605`	`public bool CancelledByOriginatingRequestCompletion { get; set; }`
`2609`	`2606`
`2610`		`- public async ValueTask<T> WaitForConnectionAsync(bool async, CancellationToken requestCancellationToken)`
	`2607`	`+ public ValueTask<T> WaitForConnectionAsync(HttpConnectionPool pool, bool async, CancellationToken requestCancellationToken)`
`2611`	`2608`	`{`
	`2609`	`+ return HttpTelemetry.Log.IsEnabled() \|\| pool.Settings._metrics!.RequestsQueueDuration.Enabled`
	`2610`	`+ ? WaitForConnectionWithTelemetryAsync(pool, async, requestCancellationToken)`
	`2611`	`+ : WaitWithCancellationAsync(async, requestCancellationToken);`
	`2612`	`+ }`
	`2613`	`+`
	`2614`	`+ private async ValueTask<T> WaitForConnectionWithTelemetryAsync(HttpConnectionPool pool, bool async, CancellationToken requestCancellationToken)`
	`2615`	`+ {`
	`2616`	`+ Debug.Assert(typeof(T) == typeof(HttpConnection) \|\| typeof(T) == typeof(Http2Connection));`
	`2617`	`+`
`2612`	`2618`	`long startingTimestamp = Stopwatch.GetTimestamp();`
`2613`	`2619`	`try`
`2614`	`2620`	`{`
`2615`	`2621`	`return await WaitWithCancellationAsync(async, requestCancellationToken).ConfigureAwait(false);`
`2616`	`2622`	`}`
`2617`	`2623`	`finally`
`2618`	`2624`	`{`
	`2625`	`+ TimeSpan duration = Stopwatch.GetElapsedTime(startingTimestamp);`
	`2626`	`+ int versionMajor = typeof(T) == typeof(HttpConnection) ? 1 : 2;`
	`2627`	`+`
	`2628`	`+ pool.Settings._metrics!.RequestLeftQueue(pool, duration, versionMajor);`
	`2629`	`+`
`2619`	`2630`	`if (HttpTelemetry.Log.IsEnabled())`
`2620`	`2631`	`{`
`2621`		`- if (typeof(T) == typeof(HttpConnection))`
`2622`		`- HttpTelemetry.Log.Http11RequestLeftQueue(Stopwatch.GetElapsedTime(startingTimestamp).TotalMilliseconds);`
`2623`		`- else if (typeof(T) == typeof(Http2Connection))`
`2624`		`- HttpTelemetry.Log.Http20RequestLeftQueue(Stopwatch.GetElapsedTime(startingTimestamp).TotalMilliseconds);`
	`2632`	`+ HttpTelemetry.Log.RequestLeftQueue(versionMajor, duration);`
`2625`	`2633`	`}`
`2626`	`2634`	`}`
`2627`	`2635`	`}`