Supporting Event counter in .Net core

src/Microsoft.Data.SqlClient/netcore/src/Common/src/Microsoft/Data/ProviderBase/DbConnectionFactory.cs

@@ -124,6 +124,7 @@ internal DbConnectionInternal CreateNonPooledConnection(DbConnection owningConne
             DbConnectionInternal newConnection = CreateConnection(connectionOptions, poolKey, poolGroupProviderInfo, null, owningConnection, userOptions);
             if (null != newConnection)
             {
+                SqlClientEventSource.Log.HardConnectRequest();
                 newConnection.MakeNonPooledObject(owningConnection);
             }
             SqlClientEventSource.Log.TryTraceEvent("<prov.DbConnectionFactory.CreateNonPooledConnection|RES|CPOOL> {0}, Non-pooled database connection created.", ObjectID);
@@ -138,6 +139,7 @@ internal DbConnectionInternal CreatePooledConnection(DbConnectionPool pool, DbCo
             DbConnectionInternal newConnection = CreateConnection(options, poolKey, poolGroupProviderInfo, pool, owningObject, userOptions);
             if (null != newConnection)
             {
+                SqlClientEventSource.Log.HardConnectRequest();
                 newConnection.MakePooledConnection(pool);
             }
             SqlClientEventSource.Log.TryTraceEvent("<prov.DbConnectionFactory.CreatePooledConnection|RES|CPOOL> {0}, Pooled database connection created.", ObjectID);
@@ -281,6 +283,7 @@ internal DbConnectionPoolGroup GetConnectionPoolGroup(DbConnectionPoolKey key, D
 
                         // lock prevents race condition with PruneConnectionPoolGroups
                         newConnectionPoolGroups.Add(key, newConnectionPoolGroup);
+                        SqlClientEventSource.Log.ActiveConnectionPoolGroupRequest();
                         connectionPoolGroup = newConnectionPoolGroup;
                         _connectionPoolGroups = newConnectionPoolGroups;
                     }
@@ -324,6 +327,7 @@ private void PruneConnectionPoolGroups(object state)
                             {
                                 _poolsToRelease.Remove(pool);
                                 SqlClientEventSource.Log.TryAdvancedTraceEvent("<prov.DbConnectionFactory.PruneConnectionPoolGroups|RES|INFO|CPOOL> {0}, ReleasePool={1}", ObjectID, pool.ObjectID);
+                                SqlClientEventSource.Log.InactiveConnectionPoolRequest(false);
                             }
                         }
                     }
@@ -348,6 +352,7 @@ private void PruneConnectionPoolGroups(object state)
                             {
                                 _poolGroupsToRelease.Remove(poolGroup);
                                 SqlClientEventSource.Log.TryAdvancedTraceEvent("<prov.DbConnectionFactory.PruneConnectionPoolGroups|RES|INFO|CPOOL> {0}, ReleasePoolGroup={1}", ObjectID, poolGroup.ObjectID);
+                                SqlClientEventSource.Log.InactiveConnectionPoolGroupRequest(false);
                             }
                         }
                     }
@@ -373,6 +378,7 @@ private void PruneConnectionPoolGroups(object state)
                         // otherwise process entry which may move it from active to idle
                         if (entry.Value.Prune())
                         { // may add entries to _poolsToRelease
+                            SqlClientEventSource.Log.ActiveConnectionPoolGroupRequest(false);
                             QueuePoolGroupForRelease(entry.Value);
                         }
                         else
@@ -405,6 +411,7 @@ internal void QueuePoolForRelease(DbConnectionPool pool, bool clearing)
                 }
                 _poolsToRelease.Add(pool);
             }
+            SqlClientEventSource.Log.InactiveConnectionPoolRequest();
         }
 
         internal void QueuePoolGroupForRelease(DbConnectionPoolGroup poolGroup)
@@ -416,6 +423,7 @@ internal void QueuePoolGroupForRelease(DbConnectionPoolGroup poolGroup)
             {
                 _poolGroupsToRelease.Add(poolGroup);
             }
+            SqlClientEventSource.Log.InactiveConnectionPoolGroupRequest();
         }
 
         virtual protected DbConnectionInternal CreateConnection(DbConnectionOptions options, DbConnectionPoolKey poolKey, object poolGroupProviderInfo, DbConnectionPool pool, DbConnection owningConnection, DbConnectionOptions userOptions)

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

@@ -231,6 +231,7 @@ internal void DeactivateConnection()
             int activateCount = Interlocked.Decrement(ref _activateCount);
 #endif // DEBUG
 
+            SqlClientEventSource.Log.ActiveConnectionRequest(false);
 
             if (!_connectionIsDoomed && Pool.UseLoadBalancing)
             {

src/Microsoft.Data.SqlClient/netcore/src/Common/src/Microsoft/Data/ProviderBase/DbConnectionPoolGroup.cs

@@ -129,6 +129,7 @@ internal int Clear()
                     if (pool != null)
                     {
                         DbConnectionFactory connectionFactory = pool.ConnectionFactory;
+                        SqlClientEventSource.Log.ActiveConnectionPoolRequest(false);
                         connectionFactory.QueuePoolForRelease(pool, true);
                     }
                 }
@@ -187,6 +188,7 @@ internal DbConnectionPool GetConnectionPool(DbConnectionFactory connectionFactor
                                     newPool.Startup(); // must start pool before usage
                                     bool addResult = _poolCollection.TryAdd(currentIdentity, newPool);
                                     Debug.Assert(addResult, "No other pool with current identity should exist at this point");
+                                    SqlClientEventSource.Log.ActiveConnectionPoolRequest();
                                     pool = newPool;
                                 }
                                 else
@@ -264,6 +266,7 @@ internal bool Prune()
                                 DbConnectionFactory connectionFactory = pool.ConnectionFactory;
 
                                 connectionFactory.QueuePoolForRelease(pool, false);
+                                SqlClientEventSource.Log.ActiveConnectionPoolRequest(false);
                             }
                             else
                             {

src/Microsoft.Data.SqlClient/netcore/src/Microsoft.Data.SqlClient.csproj

@@ -247,6 +247,10 @@
     <Compile Include="Microsoft\Data\SqlClient\EnclaveProviderBase.cs" />
     <Compile Include="Microsoft\Data\SqlClient\EnclaveSessionCache.cs" />
 	</ItemGroup>
+  <!-- netcoreapp 3.1 & netstandard 2.1 and above -->
+  <ItemGroup Condition="'$(OSGroup)' != 'AnyOS' AND '$(TargetFramework)' != 'netcoreapp2.1' AND '$(TargetFramework)' != 'netstandard2.0'">
+    <Compile Include="Microsoft\Data\SqlClient\SqlClientEventSource.NetCoreApp3.cs" />
+  </ItemGroup>
   <ItemGroup Condition="'$(OSGroup)' != 'AnyOS' AND '$(TargetGroup)' == 'netcoreapp'">
     <Compile Include="Microsoft\Data\Common\DbConnectionStringCommon.NetCoreApp.cs" />
     <Compile Include="Microsoft\Data\ProviderBase\DbConnectionPool.NetCoreApp.cs" />

src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/ProviderBase/DbConnectionFactory.cs

@@ -108,6 +108,7 @@ internal bool TryGetConnection(DbConnection owningConnection, TaskCompletionSour
                     }
 
                     connection = CreateNonPooledConnection(owningConnection, poolGroup, userOptions);
+                    SqlClientEventSource.Log.NonPooledConnectionRequest();
                 }
                 else
                 {
@@ -209,6 +210,10 @@ private static void TryGetConnectionCompletedContinuation(Task<DbConnectionInter
                     task.Result.DoomThisConnection();
                     task.Result.Dispose();
                 }
+                else
+                {
+                    SqlClientEventSource.Log.NonPooledConnectionRequest();
+                }
             }
         }
     }

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

@@ -219,6 +219,7 @@ internal void ActivateConnection(Transaction transaction)
 #endif // DEBUG
 
             Activate(transaction);
+            SqlClientEventSource.Log.ActiveConnectionRequest();
         }
 
         internal virtual void CloseConnection(DbConnection owningObject, DbConnectionFactory connectionFactory)
@@ -296,6 +297,7 @@ internal virtual void CloseConnection(DbConnection owningObject, DbConnectionFac
                         else
                         {
                             Deactivate();   // ensure we de-activate non-pooled connections, or the data readers and transactions may not get cleaned up...
+                            SqlClientEventSource.Log.HardDisconnectRequest();
 
                             // To prevent an endless recursion, we need to clear
                             // the owning object before we call dispose so that
@@ -312,6 +314,7 @@ internal virtual void CloseConnection(DbConnection owningObject, DbConnectionFac
                             }
                             else
                             {
+                                SqlClientEventSource.Log.NonPooledConnectionRequest(false);
                                 Dispose();
                             }
                         }
@@ -370,6 +373,7 @@ virtual internal void DelegatedTransactionEnded()
                 // once and for all, or the server will have fits about us
                 // leaving connections open until the client-side GC kicks 
                 // in.
+                SqlClientEventSource.Log.NonPooledConnectionRequest(false);
                 Dispose();
             }
             // When _pooledCount is 0, the connection is a pooled connection
@@ -482,6 +486,7 @@ internal void SetInStasis()
         {
             _isInStasis = true;
             SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionInternal.SetInStasis|RES|CPOOL> {0}, Non-Pooled Connection has Delegated Transaction, waiting to Dispose.", ObjectID);
+            SqlClientEventSource.Log.StasisConnectionRequest();
         }
 
         private void TerminateStasis(bool returningToPool)
@@ -494,6 +499,7 @@ private void TerminateStasis(bool returningToPool)
             {
                 SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionInternal.TerminateStasis|RES|CPOOL> {0}, Delegated Transaction has ended, connection is closed/leaked.  Disposing.", ObjectID);
             }
+            SqlClientEventSource.Log.StasisConnectionRequest(false);
             _isInStasis = false;
         }
     }

src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/ProviderBase/DbConnectionPool.cs

@@ -231,6 +231,7 @@ internal void PutTransactedObject(Transaction transaction, DbConnectionInternal
                     }
                     SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionPool.TransactedConnectionPool.PutTransactedObject|RES|CPOOL> {0}, Transaction {1}, Connection {2}, Added.", ObjectID, transaction.GetHashCode(), transactedObject.ObjectID);
                 }
+                SqlClientEventSource.Log.FreeConnectionRequest();
             }
 
             internal void TransactionEnded(Transaction transaction, DbConnectionInternal transactedObject)
@@ -293,6 +294,7 @@ internal void TransactionEnded(Transaction transaction, DbConnectionInternal tra
                 // connections, we'll put it back...
                 if (0 <= entry)
                 {
+                    SqlClientEventSource.Log.FreeConnectionRequest();
                     Pool.PutObjectFromTransactedPool(transactedObject);
                 }
             }
@@ -600,6 +602,7 @@ private void CleanupCallback(object state)
                     {
                         Debug.Assert(obj != null, "null connection is not expected");
                         // If we obtained one from the old stack, destroy it.
+                        SqlClientEventSource.Log.FreeConnectionRequest(false);
 
                         // Transaction roots must survive even aging out (TxEnd event will clean them up).
                         bool shouldDestroy = true;
@@ -696,11 +699,13 @@ internal void Clear()
             while (_stackNew.TryPop(out obj))
             {
                 Debug.Assert(obj != null, "null connection is not expected");
+                SqlClientEventSource.Log.FreeConnectionRequest(false);
                 DestroyObject(obj);
             }
             while (_stackOld.TryPop(out obj))
             {
                 Debug.Assert(obj != null, "null connection is not expected");
+                SqlClientEventSource.Log.FreeConnectionRequest(false);
                 DestroyObject(obj);
             }
 
@@ -742,6 +747,7 @@ private DbConnectionInternal CreateObject(DbConnection owningObject, DbConnectio
                     }
                     _objectList.Add(newObj);
                     _totalObjects = _objectList.Count;
+                    SqlClientEventSource.Log.PooledConnectionRequest();
                 }
 
                 // If the old connection belonged to another pool, we need to remove it from that
@@ -967,9 +973,11 @@ internal void DestroyObject(DbConnectionInternal obj)
                 if (removed)
                 {
                     SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionPool.DestroyObject|RES|CPOOL> {0}, Connection {1}, Removed from pool.", ObjectID, obj.ObjectID);
+                    SqlClientEventSource.Log.PooledConnectionRequest(false);
                 }
                 obj.Dispose();
                 SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionPool.DestroyObject|RES|CPOOL> {0}, Connection {1}, Disposed.", ObjectID, obj.ObjectID);
+                SqlClientEventSource.Log.HardDisconnectRequest();
             }
         }
 
@@ -1301,6 +1309,7 @@ private bool TryGetConnection(DbConnection owningObject, uint waitForMultipleObj
             }
 
             connection = obj;
+            SqlClientEventSource.Log.SoftConnectRequest();
             return true;
         }
 
@@ -1337,6 +1346,7 @@ internal DbConnectionInternal ReplaceConnection(DbConnection owningObject, DbCon
 
             if (newConnection != null)
             {
+                SqlClientEventSource.Log.SoftConnectRequest();
                 PrepareConnection(owningObject, newConnection, oldConnection.EnlistedTransaction);
                 oldConnection.PrepareForReplaceConnection();
                 oldConnection.DeactivateConnection();
@@ -1374,6 +1384,7 @@ private DbConnectionInternal GetFromGeneralPool()
             if (null != obj)
             {
                 SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionPool.GetFromGeneralPool|RES|CPOOL> {0}, Connection {1}, Popped from general pool.", ObjectID, obj.ObjectID);
+                SqlClientEventSource.Log.FreeConnectionRequest(false);
             }
             return (obj);
         }
@@ -1390,6 +1401,7 @@ private DbConnectionInternal GetFromTransactedPool(out Transaction transaction)
                 if (null != obj)
                 {
                     SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionPool.GetFromTransactedPool|RES|CPOOL> {0}, Connection {1}, Popped from transacted pool.", ObjectID, obj.ObjectID);
+                    SqlClientEventSource.Log.FreeConnectionRequest(false);
 
                     if (obj.IsTransactionRoot)
                     {
@@ -1544,12 +1556,13 @@ internal void PutNewObject(DbConnectionInternal obj)
 
             _stackNew.Push(obj);
             _waitHandles.PoolSemaphore.Release(1);
+            SqlClientEventSource.Log.FreeConnectionRequest();
         }
 
         internal void PutObject(DbConnectionInternal obj, object owningObject)
         {
             Debug.Assert(null != obj, "null obj?");
-
+            SqlClientEventSource.Log.SoftDisconnectRequest();
 
             // Once a connection is closing (which is the state that we're in at
             // this point in time) you cannot delegate a transaction to or enlist
@@ -1662,6 +1675,8 @@ private bool ReclaimEmancipatedObjects()
             {
                 DbConnectionInternal obj = reclaimedObjects[i];
                 SqlClientEventSource.Log.TryPoolerTraceEvent("<prov.DbConnectionPool.ReclaimEmancipatedObjects|RES|CPOOL> {0}, Connection {1}, Reclaiming.", ObjectID, obj.ObjectID);
+                SqlClientEventSource.Log.ReclaimedConnectionRequest();
+
                 emancipatedObjectFound = true;
 
                 obj.DetachCurrentTransactionIfEnded();