Add more System.Net.Http counters

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

@@ -20,6 +20,11 @@ internal sealed class HttpTelemetry : EventSource
         private PollingCounter? _currentRequestsCounter;
         private PollingCounter? _abortedRequestsCounter;
 
+#if !TARGETS_BROWSER
+        private PollingCounter? _maxHttp11ConnectionsPerPoolCounter;
+        private PollingCounter? _maxHttp20StreamsPerConnectionCounter;
+#endif
+
         private long _startedRequests;
         private long _stoppedRequests;
         private long _abortedRequests;
@@ -96,6 +101,18 @@ protected override void OnEventCommand(EventCommandEventArgs command)
                 {
                     DisplayName = "Current Requests"
                 };
+
+#if !TARGETS_BROWSER
+                _maxHttp11ConnectionsPerPoolCounter ??= new PollingCounter("http11-connections-single-pool-max", this, () => HttpConnectionPoolManager.GetMaxHttp11ConnectionsPerPool())
+                {
+                    DisplayName = "Maximum Http 1.1 Connections per Connection Pool"
+                };
+
+                _maxHttp20StreamsPerConnectionCounter ??= new PollingCounter("http20-streams-single-connection-max", this, () => HttpConnectionPoolManager.GetMaxHttp20StreamsPerConnection())
+                {
+                    DisplayName = "Maximum Http Streams per Http 2.0 Connection"
+                };
+#endif
             }
         }
 

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs

@@ -1559,6 +1559,8 @@ public void Dispose()
             }
         }
 
+        public int HttpStreamCount => _httpStreams.Count;
+
         private enum FrameType : byte
         {
             Data = 0,

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs

@@ -1553,6 +1553,10 @@ private void Trace(string? message, [CallerMemberName] string? memberName = null
                 memberName,                  // method name
                 message);                    // message
 
+        public int Http11ConnectionCount => _associatedConnectionCount;
+
+        public int Http20StreamCount => _http2Connection?.HttpStreamCount ?? 0;
+
         /// <summary>A cached idle connection and metadata about it.</summary>
         [StructLayout(LayoutKind.Auto)]
         private readonly struct CachedConnection : IEquatable<CachedConnection>

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPoolManager.cs

@@ -31,6 +31,10 @@ namespace System.Net.Http
     /// <summary>Provides a set of connection pools, each for its own endpoint.</summary>
     internal sealed class HttpConnectionPoolManager : IDisposable
     {
+        // Used by HttpTelemetry to calculate statistics over all connection pools
+        private static readonly ConcurrentDictionary<WeakReference<HttpConnectionPoolManager>, object?> s_allConnectionPools =
+            new ConcurrentDictionary<WeakReference<HttpConnectionPoolManager>, object?>();
+
         /// <summary>How frequently an operation should be initiated to clean out old pools and connections in those pools.</summary>
         private readonly TimeSpan _cleanPoolTimeout;
         /// <summary>The pools, indexed by endpoint.</summary>
@@ -44,6 +48,8 @@ internal sealed class HttpConnectionPoolManager : IDisposable
         private readonly IWebProxy? _proxy;
         private readonly ICredentials? _proxyCredentials;
 
+        private readonly WeakReference<HttpConnectionPoolManager>? _weakThisRef;
+
         private NetworkChangeCleanup? _networkChangeCleanup;
 
         /// <summary>
@@ -103,14 +109,19 @@ public HttpConnectionPoolManager(HttpConnectionSettings settings)
                     // Create the timer.  Ensure the Timer has a weak reference to this manager; otherwise, it
                     // can introduce a cycle that keeps the HttpConnectionPoolManager rooted by the Timer
                     // implementation until the handler is Disposed (or indefinitely if it's not).
+                    _weakThisRef = new WeakReference<HttpConnectionPoolManager>(this);
+
                     _cleaningTimer = new Timer(s =>
                     {
                         var wr = (WeakReference<HttpConnectionPoolManager>)s!;
                         if (wr.TryGetTarget(out HttpConnectionPoolManager? thisRef))
                         {
                             thisRef.RemoveStalePools();
                         }
-                    }, new WeakReference<HttpConnectionPoolManager>(this), Timeout.Infinite, Timeout.Infinite);
+                    }, _weakThisRef, Timeout.Infinite, Timeout.Infinite);
+
+                    bool success = s_allConnectionPools.TryAdd(_weakThisRef, null);
+                    Debug.Assert(success);
                 }
                 finally
                 {
@@ -121,6 +132,10 @@ public HttpConnectionPoolManager(HttpConnectionSettings settings)
                     }
                 }
             }
+            else
+            {
+                GC.SuppressFinalize(this);
+            }
 
             // Figure out proxy stuff.
             if (settings._useProxy)
@@ -133,6 +148,14 @@ public HttpConnectionPoolManager(HttpConnectionSettings settings)
             }
         }
 
+        ~HttpConnectionPoolManager()
+        {
+            if (_weakThisRef != null)
+            {
+                s_allConnectionPools.TryRemove(_weakThisRef, out _);
+            }
+        }
+
         /// <summary>
         /// Starts monitoring for network changes. Upon a change, <see cref="HttpConnectionPool.OnNetworkChanged"/> will be
         /// called for every <see cref="HttpConnectionPool"/> in the <see cref="HttpConnectionPoolManager"/>.
@@ -455,6 +478,12 @@ public void Dispose()
         {
             _cleaningTimer?.Dispose();
 
+            if (_weakThisRef != null)
+            {
+                s_allConnectionPools.TryRemove(_weakThisRef, out _);
+                GC.SuppressFinalize(this);
+            }
+
             foreach (KeyValuePair<HttpConnectionKey, HttpConnectionPool> pool in _pools)
             {
                 pool.Value.Dispose();
@@ -527,6 +556,38 @@ private static string GetIdentityIfDefaultCredentialsUsed(bool defaultCredential
             return defaultCredentialsUsed ? CurrentUserIdentityProvider.GetIdentity() : string.Empty;
         }
 
+        public static int GetMaxHttp11ConnectionsPerPool()
+        {
+            int max = 0;
+            foreach ((WeakReference<HttpConnectionPoolManager> weakConnectionPoolManagerRef, _) in s_allConnectionPools)
+            {
+                if (weakConnectionPoolManagerRef.TryGetTarget(out HttpConnectionPoolManager? connectionPoolManager))
+                {
+                    foreach ((_, HttpConnectionPool connectionPool) in connectionPoolManager._pools)
+                    {
+                        max = Math.Max(max, connectionPool.Http11ConnectionCount);
+                    }
+                }
+            }
+            return max;
+        }
+
+        public static int GetMaxHttp20StreamsPerConnection()
+        {
+            int max = 0;
+            foreach ((WeakReference<HttpConnectionPoolManager> weakConnectionPoolManagerRef, _) in s_allConnectionPools)
+            {
+                if (weakConnectionPoolManagerRef.TryGetTarget(out HttpConnectionPoolManager? connectionPoolManager))
+                {
+                    foreach ((_, HttpConnectionPool connectionPool) in connectionPoolManager._pools)
+                    {
+                        max = Math.Max(max, connectionPool.Http20StreamCount);
+                    }
+                }
+            }
+            return max;
+        }
+
         internal readonly struct HttpConnectionKey : IEquatable<HttpConnectionKey>
         {
             public readonly HttpConnectionKind Kind;