Emit pool metrics and traces, and fix Count semantics in ChannelDbConnectionPool

src/Microsoft.Data.SqlClient/src/Microsoft/Data/ProviderBase/DbConnectionInternal.cs

@@ -12,6 +12,7 @@
 using Microsoft.Data.Common;
 using Microsoft.Data.SqlClient;
 using Microsoft.Data.SqlClient.ConnectionPool;
+using Microsoft.Data.SqlClient.Diagnostics;
 using Microsoft.Data.SqlClient.Internal;
 
 #if NETFRAMEWORK
@@ -75,8 +76,20 @@ protected DbConnectionInternal() : this(ConnectionState.Open, true, false)
         {
         }
 
+        // Constructor for internal connections that report to a specific metrics sink, reusing
+        // the same defaults as the parameterless constructor above.
+        protected DbConnectionInternal(ISqlClientMetrics metrics) : this(ConnectionState.Open, true, false, metrics)
+        {
+        }
+
         // Constructor for internal connections
         internal DbConnectionInternal(ConnectionState state, bool hidePassword, bool allowSetConnectionString)
+            : this(state, hidePassword, allowSetConnectionString, metrics: null)
+        {
+        }
+
+        // Constructor for internal connections
+        internal DbConnectionInternal(ConnectionState state, bool hidePassword, bool allowSetConnectionString, ISqlClientMetrics metrics)
         {
             AllowSetConnectionString = allowSetConnectionString;
             ShouldHidePassword = hidePassword;
@@ -87,6 +100,7 @@ internal DbConnectionInternal(ConnectionState state, bool hidePassword, bool all
             // Without this initialization, ReturnedTime would default to DateTime.MinValue, which would cause
             // IsLiveConnection to immediately evict every new connection whenever IdleTimeout is configured.
             ReturnedTime = CreateTime;
+            Metrics = metrics ?? SqlClientDiagnostics.Metrics;
         }
 
         #region Properties
@@ -179,6 +193,16 @@ internal bool IsInPool
         /// </summary>
         internal IDbConnectionPool Pool { get; private set; }
 
+        /// <summary>
+        /// The metrics sink this connection reports its activation state to. Supplied by the
+        /// <see cref="SqlConnectionFactory"/> that created this connection, from its own injected
+        /// instance, rather than derived from <see cref="Pool"/>: the metrics sink is not
+        /// inherently tied to a pool, and a connection is not necessarily pooled at all. Defaults
+        /// to the process-wide instance when no metrics sink is supplied to the constructor (e.g.
+        /// a test double constructed directly), so it still reports somewhere.
+        /// </summary>
+        internal ISqlClientMetrics Metrics { get; }
+
         public abstract string ServerVersion { get; }
 
         public virtual ConnectionCapabilities Capabilities => null;
@@ -366,9 +390,13 @@ internal void ActivateConnection(Transaction transaction)
             // the Activate method publicly.
             SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionInternal.ActivateConnection|RES|INFO|CPOOL> {0}, Activating", ObjectID);
 
-            Activate(transaction);
+            // Counted before Activate, mirroring DeactivateConnection, which counts before
+            // Deactivate. If Activate throws, the pool returns the connection and deactivates it,
+            // so counting afterwards would leave that exit unpaired and drive the
+            // active-connections gauge negative.
+            Metrics.EnterActiveConnection();
 
-            SqlClientDiagnostics.Metrics.EnterActiveConnection();
+            Activate(transaction);
         }
 
         internal void AddWeakReference(object value, int tag)
@@ -481,7 +509,7 @@ internal virtual void CloseConnection(DbConnection owningObject, SqlConnectionFa
                             // and transactions may not get cleaned up...
                             Deactivate();
 
-                            SqlClientDiagnostics.Metrics.HardDisconnectRequest();
+                            Metrics.HardDisconnectRequest();
 
                             // To prevent an endless recursion, we need to clear the owning object
                             // before we call dispose so that we can't get here a second time...
@@ -496,7 +524,7 @@ internal virtual void CloseConnection(DbConnection owningObject, SqlConnectionFa
                             }
                             else
                             {
-                                SqlClientDiagnostics.Metrics.ExitNonPooledConnection();
+                                Metrics.ExitNonPooledConnection();
                                 Dispose();
                             }
                         }
@@ -522,7 +550,7 @@ internal void DeactivateConnection()
             // the Deactivate method publicly.
             SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionInternal.DeactivateConnection|RES|INFO|CPOOL> {0}, Deactivating", ObjectID);
 
-            SqlClientDiagnostics.Metrics.ExitActiveConnection();
+            Metrics.ExitActiveConnection();
 
             if (!IsConnectionDoomed && Pool.UseLoadBalancing)
             {
@@ -582,7 +610,7 @@ internal virtual void DelegatedTransactionEnded()
                 // once and for all, or the server will have fits about us
                 // leaving connections open until the client-side GC kicks
                 // in.
-                SqlClientDiagnostics.Metrics.ExitNonPooledConnection();
+                Metrics.ExitNonPooledConnection();
 
                 Dispose();
             }
@@ -812,7 +840,7 @@ internal void SetInStasis()
             IsTxRootWaitingForTxEnd = true;
             SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionInternal.SetInStasis|RES|CPOOL> {0}, Non-Pooled Connection has Delegated Transaction, waiting to Dispose.", ObjectID);
 
-            SqlClientDiagnostics.Metrics.EnterStasisConnection();
+            Metrics.EnterStasisConnection();
         }
 
         /// <remarks>
@@ -998,7 +1026,7 @@ private void TerminateStasis(bool returningToPool)
                 : "Delegated Transaction has ended, connection is closed/leaked.  Disposing.";
             SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionInternal.TerminateStasis|RES|CPOOL> {0}, {1}", ObjectID, message);
 
-            SqlClientDiagnostics.Metrics.ExitStasisConnection();
+            Metrics.ExitStasisConnection();
 
             IsTxRootWaitingForTxEnd = false;
         }

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/Connection/SqlConnectionInternal.cs

@@ -15,6 +15,7 @@
 using Microsoft.Data.Common;
 using Microsoft.Data.ProviderBase;
 using Microsoft.Data.SqlClient.ConnectionPool;
+using Microsoft.Data.SqlClient.Diagnostics;
 using Microsoft.Data.SqlClient.Internal;
 using Microsoft.Data.SqlClient.Utilities;
 using IsolationLevel = System.Data.IsolationLevel;
@@ -306,7 +307,9 @@ internal SqlConnectionInternal(
             string accessToken = null,
             IDbConnectionPool pool = null,
             Func<SqlAuthenticationParameters, CancellationToken, Task<SqlAuthenticationToken>> accessTokenCallback = null,
-            SspiContextProvider sspiContextProvider = null)
+            SspiContextProvider sspiContextProvider = null,
+            ISqlClientMetrics metrics = null)
+            : base(metrics)
         {
             Debug.Assert(connectionOptions is not null, "null connectionOptions");