Enable SqlCommand telemetry

edwardneal · edwardneal · commit d14a56134fd4 · 2025-07-24T20:43:07.000+01:00
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlCommand.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlCommand.cs
@@ -1233,7 +1233,7 @@ public override int ExecuteNonQuery()
             // between entry into Execute* API and the thread obtaining the stateObject.
             _pendingCancel = false;
 
-            using (var diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))
+            using (DiagnosticScope diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))
             using (TryEventScope.Create("SqlCommand.ExecuteNonQuery | API | Object Id {0}", ObjectID))
             {
                 SqlStatistics statistics = null;
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlCommand.cs b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlCommand.cs
@@ -21,6 +21,7 @@
 using System.Buffers;
 using Microsoft.Data.Common;
 using Microsoft.Data.Sql;
+using Microsoft.Data.SqlClient.Diagnostics;
 using Microsoft.Data.SqlClient.Server;
 using System.Transactions;
 using System.Collections.Concurrent;
@@ -162,6 +163,10 @@ protected override void AfterCleared(SqlCommand owner)
         /// </summary>
         private static bool _forceRetryableEnclaveQueryExecutionExceptionDuringGenerateEnclavePackage = false;
 #endif
+
+        private static readonly SqlDiagnosticListener s_diagnosticListener = new SqlDiagnosticListener();
+        private bool _parentOperationStarted = false;
+
         internal static readonly Action<object> s_cancelIgnoreFailure = CancelIgnoreFailureCallback;
 
         // Prepare
@@ -632,7 +637,8 @@ internal SqlStatistics Statistics
             {
                 if (_activeConnection != null)
                 {
-                    if (_activeConnection.StatisticsEnabled)
+                    if (_activeConnection.StatisticsEnabled ||
+                        s_diagnosticListener.IsEnabled(SqlClientCommandAfter.Name))
                     {
                         return _activeConnection.Statistics;
                     }
@@ -1228,6 +1234,7 @@ public override object ExecuteScalar()
             _pendingCancel = false;
             SqlStatistics statistics = null;
 
+            using (DiagnosticScope diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))
             using (TryEventScope.Create("SqlCommand.ExecuteScalar | API | ObjectId {0}", ObjectID))
             {
                 bool success = false;
@@ -1245,9 +1252,13 @@ public override object ExecuteScalar()
                     success = true;
                     return result;
                 }
-                catch (SqlException ex)
+                catch (Exception ex)
                 {
-                    sqlExceptionNumber = ex.Number;
+                    diagnosticScope.SetException(ex);
+                    if (ex is SqlException sqlException)
+                    {
+                        sqlExceptionNumber = sqlException.Number;
+                    }
                     throw;
                 }
                 finally
@@ -1318,6 +1329,7 @@ public override int ExecuteNonQuery()
 
             SqlStatistics statistics = null;
 
+            using (DiagnosticScope diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))
             using (TryEventScope.Create("<sc.SqlCommand.ExecuteNonQuery|API> {0}", ObjectID))
             {
                 bool success = false;
@@ -1344,9 +1356,13 @@ public override int ExecuteNonQuery()
                     success = true;
                     return _rowsAffected;
                 }
-                catch (SqlException ex)
+                catch (Exception ex)
                 {
-                    sqlExceptionNumber = ex.Number;
+                    diagnosticScope.SetException(ex);
+                    if (ex is SqlException sqlException)
+                    {
+                        sqlExceptionNumber = sqlException.Number;
+                    }
                     throw;
                 }
                 finally
@@ -1916,6 +1932,7 @@ public XmlReader ExecuteXmlReader()
 
             SqlStatistics statistics = null;
 
+            using (DiagnosticScope diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))
             using (TryEventScope.Create("SqlCommand.ExecuteXmlReader | API | Object Id {0}", ObjectID))
             {
                 bool success = false;
@@ -1935,9 +1952,13 @@ public XmlReader ExecuteXmlReader()
                     success = true;
                     return result;
                 }
-                catch (SqlException ex)
+                catch (Exception ex)
                 {
-                    sqlExceptionNumber = ex.Number;
+                    diagnosticScope.SetException(ex);
+                    if (ex is SqlException sqlException)
+                    {
+                        sqlExceptionNumber = sqlException.Number;
+                    }
                     throw;
                 }
                 finally
@@ -2293,6 +2314,8 @@ protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
             RuntimeHelpers.PrepareConstrainedRegions();
             bool success = false;
             int? sqlExceptionNumber = null;
+            Exception e = null;
+            Guid operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);
 
             using (TryEventScope.Create("SqlCommand.ExecuteReader | API | Object Id {0}", ObjectID))
             {
@@ -2307,31 +2330,44 @@ protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
                     success = true;
                     return result;
                 }
-                catch (SqlException e)
+                catch (System.OutOfMemoryException ex)
                 {
-                    sqlExceptionNumber = e.Number;
+                    _activeConnection.Abort(ex);
                     throw;
                 }
-                catch (System.OutOfMemoryException e)
+                catch (System.StackOverflowException ex)
                 {
-                    _activeConnection.Abort(e);
+                    _activeConnection.Abort(ex);
                     throw;
                 }
-                catch (System.StackOverflowException e)
+                catch (System.Threading.ThreadAbortException ex)
                 {
-                    _activeConnection.Abort(e);
+                    _activeConnection.Abort(ex);
+                    SqlInternalConnection.BestEffortCleanup(bestEffortCleanupTarget);
                     throw;
                 }
-                catch (System.Threading.ThreadAbortException e)
+                catch (Exception ex)
                 {
-                    _activeConnection.Abort(e);
-                    SqlInternalConnection.BestEffortCleanup(bestEffortCleanupTarget);
+                    if (ex is SqlException sqlException)
+                    {
+                        sqlExceptionNumber = sqlException.Number;
+                    }
+
+                    e = ex;
                     throw;
                 }
                 finally
                 {
                     SqlStatistics.StopTimer(statistics);
                     WriteEndExecuteEvent(success, sqlExceptionNumber, synchronous: true);
+                    if (e != null)
+                    {
+                        s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);
+                    }
+                    else
+                    {
+                        s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);
+                    }
                 }
             }
         }
@@ -2433,10 +2469,18 @@ private void CleanupExecuteReaderAsync(Task<SqlDataReader> task, TaskCompletionS
             if (task.IsFaulted)
             {
                 Exception e = task.Exception.InnerException;
+                if (!_parentOperationStarted)
+                {
+                    s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);
+                }
                 source.SetException(e);
             }
             else
             {
+                if (!_parentOperationStarted)
+                {
+                    s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);
+                }
                 if (task.IsCanceled)
                 {
                     source.SetCanceled();
@@ -2832,7 +2876,7 @@ private Task<int> InternalExecuteNonQueryAsync(CancellationToken cancellationTok
         {
             SqlClientEventSource.Log.TryCorrelationTraceEvent("SqlCommand.InternalExecuteNonQueryAsync | API | Correlation | Object Id {0}, Activity Id {1}, Client Connection Id {2}, Command Text '{3}'", ObjectID, ActivityCorrelator.Current, Connection?.ClientConnectionId, CommandText);
             SqlConnection.ExecutePermission.Demand();
-            Guid operationId = Guid.Empty;
+            Guid operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);
 
             // connection can be used as state in RegisterForConnectionCloseNotification continuation
             // to avoid an allocation so use it as the state value if possible but it can be changed if
@@ -2885,6 +2929,7 @@ private Task<int> InternalExecuteNonQueryAsync(CancellationToken cancellationTok
             }
             catch (Exception e)
             {
+                s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);
                 source.SetException(e);
                 context.Dispose();
             }
@@ -2897,6 +2942,7 @@ private void CleanupAfterExecuteNonQueryAsync(Task<int> task, TaskCompletionSour
             if (task.IsFaulted)
             {
                 Exception e = task.Exception.InnerException;
+                s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);
                 source.SetException(e);
             }
             else
@@ -2909,6 +2955,7 @@ private void CleanupAfterExecuteNonQueryAsync(Task<int> task, TaskCompletionSour
                 {
                     source.SetResult(task.Result);
                 }
+                s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);
             }
         }
 
@@ -2960,6 +3007,10 @@ private Task<SqlDataReader> InternalExecuteReaderAsync(CommandBehavior behavior,
             SqlClientEventSource.Log.TryTraceEvent("SqlCommand.InternalExecuteReaderAsync | API> {0}, Client Connection Id {1}, Command Text = '{2}'", ObjectID, Connection?.ClientConnectionId, CommandText);
             SqlConnection.ExecutePermission.Demand();
             Guid operationId = default(Guid);
+            if (!_parentOperationStarted)
+            {
+                operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);
+            }
 
             // connection can be used as state in RegisterForConnectionCloseNotification continuation
             // to avoid an allocation so use it as the state value if possible but it can be changed if
@@ -3021,6 +3072,11 @@ private Task<SqlDataReader> InternalExecuteReaderAsync(CommandBehavior behavior,
             }
             catch (Exception e)
             {
+                if (!_parentOperationStarted)
+                {
+                    s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);
+                }
+
                 source.SetException(e);
                 context?.Dispose();
             }
@@ -3059,6 +3115,9 @@ public override Task<object> ExecuteScalarAsync(CancellationToken cancellationTo
 
         private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationToken)
         {
+            _parentOperationStarted = true;
+            Guid operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);
+
             return ExecuteReaderAsync(cancellationToken).ContinueWith((executeTask) =>
             {
                 TaskCompletionSource<object> source = new TaskCompletionSource<object>();
@@ -3068,6 +3127,7 @@ private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationTo
                 }
                 else if (executeTask.IsFaulted)
                 {
+                    s_diagnosticListener.WriteCommandError(operationId, this, _transaction, executeTask.Exception.InnerException);
                     source.SetException(executeTask.Exception.InnerException);
                 }
                 else
@@ -3086,6 +3146,7 @@ private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationTo
                                 else if (readTask.IsFaulted)
                                 {
                                     reader.Dispose();
+                                    s_diagnosticListener.WriteCommandError(operationId, this, _transaction, readTask.Exception.InnerException);
                                     source.SetException(readTask.Exception.InnerException);
                                 }
                                 else
@@ -3113,10 +3174,12 @@ private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationTo
                                     }
                                     if (exception != null)
                                     {
+                                        s_diagnosticListener.WriteCommandError(operationId, this, _transaction, exception);
                                         source.SetException(exception);
                                     }
                                     else
                                     {
+                                        s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);
                                         source.SetResult(result);
                                     }
                                 }
@@ -3130,6 +3193,7 @@ private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationTo
                         TaskScheduler.Default
                     );
                 }
+                _parentOperationStarted = false;
                 return source.Task;
             }, TaskScheduler.Default).Unwrap();
         }
@@ -3154,7 +3218,7 @@ private Task<XmlReader> InternalExecuteXmlReaderAsync(CancellationToken cancella
         {
             SqlClientEventSource.Log.TryCorrelationTraceEvent("SqlCommand.InternalExecuteXmlReaderAsync | API | Correlation | Object Id {0}, Activity Id {1}, Client Connection Id {2}, Command Text '{3}'", ObjectID, ActivityCorrelator.Current, Connection?.ClientConnectionId, CommandText);
             SqlConnection.ExecutePermission.Demand();
-            Guid operationId = Guid.Empty;
+            Guid operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);
 
             // connection can be used as state in RegisterForConnectionCloseNotification continuation
             // to avoid an allocation so use it as the state value if possible but it can be changed if
@@ -3214,6 +3278,7 @@ private Task<XmlReader> InternalExecuteXmlReaderAsync(CancellationToken cancella
             }
             catch (Exception e)
             {
+                s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);
                 source.SetException(e);
             }
 
@@ -3225,6 +3290,7 @@ private void CleanupAfterExecuteXmlReaderAsync(Task<XmlReader> task, TaskComplet
             if (task.IsFaulted)
             {
                 Exception e = task.Exception.InnerException;
+                s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);
                 source.SetException(e);
             }
             else
@@ -3237,6 +3303,7 @@ private void CleanupAfterExecuteXmlReaderAsync(Task<XmlReader> task, TaskComplet
                 {
                     source.SetResult(task.Result);
                 }
+                s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -1233,7 +1233,7 @@ public override int ExecuteNonQuery()`
`1233`	`1233`	`// between entry into Execute* API and the thread obtaining the stateObject.`
`1234`	`1234`	`_pendingCancel = false;`
`1235`	`1235`
`1236`		`- using (var diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))`
	`1236`	`+ using (DiagnosticScope diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))`
`1237`	`1237`	`using (TryEventScope.Create("SqlCommand.ExecuteNonQuery \| API \| Object Id {0}", ObjectID))`
`1238`	`1238`	`{`
`1239`	`1239`	`SqlStatistics statistics = null;`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`using System.Buffers;`
`22`	`22`	`using Microsoft.Data.Common;`
`23`	`23`	`using Microsoft.Data.Sql;`
	`24`	`+using Microsoft.Data.SqlClient.Diagnostics;`
`24`	`25`	`using Microsoft.Data.SqlClient.Server;`
`25`	`26`	`using System.Transactions;`
`26`	`27`	`using System.Collections.Concurrent;`
`@@ -162,6 +163,10 @@ protected override void AfterCleared(SqlCommand owner)`
`162`	`163`	`/// </summary>`
`163`	`164`	`private static bool _forceRetryableEnclaveQueryExecutionExceptionDuringGenerateEnclavePackage = false;`
`164`	`165`	`#endif`
	`166`	`+`
	`167`	`+ private static readonly SqlDiagnosticListener s_diagnosticListener = new SqlDiagnosticListener();`
	`168`	`+ private bool _parentOperationStarted = false;`
	`169`	`+`
`165`	`170`	`internal static readonly Action<object> s_cancelIgnoreFailure = CancelIgnoreFailureCallback;`
`166`	`171`
`167`	`172`	`// Prepare`
`@@ -632,7 +637,8 @@ internal SqlStatistics Statistics`
`632`	`637`	`{`
`633`	`638`	`if (_activeConnection != null)`
`634`	`639`	`{`
`635`		`- if (_activeConnection.StatisticsEnabled)`
	`640`	`+ if (_activeConnection.StatisticsEnabled \|\|`
	`641`	`+ s_diagnosticListener.IsEnabled(SqlClientCommandAfter.Name))`
`636`	`642`	`{`
`637`	`643`	`return _activeConnection.Statistics;`
`638`	`644`	`}`
`@@ -1228,6 +1234,7 @@ public override object ExecuteScalar()`
`1228`	`1234`	`_pendingCancel = false;`
`1229`	`1235`	`SqlStatistics statistics = null;`
`1230`	`1236`
	`1237`	`+ using (DiagnosticScope diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))`
`1231`	`1238`	`using (TryEventScope.Create("SqlCommand.ExecuteScalar \| API \| ObjectId {0}", ObjectID))`
`1232`	`1239`	`{`
`1233`	`1240`	`bool success = false;`
`@@ -1245,9 +1252,13 @@ public override object ExecuteScalar()`
`1245`	`1252`	`success = true;`
`1246`	`1253`	`return result;`
`1247`	`1254`	`}`
`1248`		`- catch (SqlException ex)`
	`1255`	`+ catch (Exception ex)`
`1249`	`1256`	`{`
`1250`		`- sqlExceptionNumber = ex.Number;`
	`1257`	`+ diagnosticScope.SetException(ex);`
	`1258`	`+ if (ex is SqlException sqlException)`
	`1259`	`+ {`
	`1260`	`+ sqlExceptionNumber = sqlException.Number;`
	`1261`	`+ }`
`1251`	`1262`	`throw;`
`1252`	`1263`	`}`
`1253`	`1264`	`finally`
`@@ -1318,6 +1329,7 @@ public override int ExecuteNonQuery()`
`1318`	`1329`
`1319`	`1330`	`SqlStatistics statistics = null;`
`1320`	`1331`
	`1332`	`+ using (DiagnosticScope diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))`
`1321`	`1333`	`using (TryEventScope.Create("<sc.SqlCommand.ExecuteNonQuery\|API> {0}", ObjectID))`
`1322`	`1334`	`{`
`1323`	`1335`	`bool success = false;`
`@@ -1344,9 +1356,13 @@ public override int ExecuteNonQuery()`
`1344`	`1356`	`success = true;`
`1345`	`1357`	`return _rowsAffected;`
`1346`	`1358`	`}`
`1347`		`- catch (SqlException ex)`
	`1359`	`+ catch (Exception ex)`
`1348`	`1360`	`{`
`1349`		`- sqlExceptionNumber = ex.Number;`
	`1361`	`+ diagnosticScope.SetException(ex);`
	`1362`	`+ if (ex is SqlException sqlException)`
	`1363`	`+ {`
	`1364`	`+ sqlExceptionNumber = sqlException.Number;`
	`1365`	`+ }`
`1350`	`1366`	`throw;`
`1351`	`1367`	`}`
`1352`	`1368`	`finally`
`@@ -1916,6 +1932,7 @@ public XmlReader ExecuteXmlReader()`
`1916`	`1932`
`1917`	`1933`	`SqlStatistics statistics = null;`
`1918`	`1934`
	`1935`	`+ using (DiagnosticScope diagnosticScope = s_diagnosticListener.CreateCommandScope(this, _transaction))`
`1919`	`1936`	`using (TryEventScope.Create("SqlCommand.ExecuteXmlReader \| API \| Object Id {0}", ObjectID))`
`1920`	`1937`	`{`
`1921`	`1938`	`bool success = false;`
`@@ -1935,9 +1952,13 @@ public XmlReader ExecuteXmlReader()`
`1935`	`1952`	`success = true;`
`1936`	`1953`	`return result;`
`1937`	`1954`	`}`
`1938`		`- catch (SqlException ex)`
	`1955`	`+ catch (Exception ex)`
`1939`	`1956`	`{`
`1940`		`- sqlExceptionNumber = ex.Number;`
	`1957`	`+ diagnosticScope.SetException(ex);`
	`1958`	`+ if (ex is SqlException sqlException)`
	`1959`	`+ {`
	`1960`	`+ sqlExceptionNumber = sqlException.Number;`
	`1961`	`+ }`
`1941`	`1962`	`throw;`
`1942`	`1963`	`}`
`1943`	`1964`	`finally`
`@@ -2293,6 +2314,8 @@ protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)`
`2293`	`2314`	`RuntimeHelpers.PrepareConstrainedRegions();`
`2294`	`2315`	`bool success = false;`
`2295`	`2316`	`int? sqlExceptionNumber = null;`
	`2317`	`+ Exception e = null;`
	`2318`	`+ Guid operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);`
`2296`	`2319`
`2297`	`2320`	`using (TryEventScope.Create("SqlCommand.ExecuteReader \| API \| Object Id {0}", ObjectID))`
`2298`	`2321`	`{`
`@@ -2307,31 +2330,44 @@ protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)`
`2307`	`2330`	`success = true;`
`2308`	`2331`	`return result;`
`2309`	`2332`	`}`
`2310`		`- catch (SqlException e)`
	`2333`	`+ catch (System.OutOfMemoryException ex)`
`2311`	`2334`	`{`
`2312`		`- sqlExceptionNumber = e.Number;`
	`2335`	`+ _activeConnection.Abort(ex);`
`2313`	`2336`	`throw;`
`2314`	`2337`	`}`
`2315`		`- catch (System.OutOfMemoryException e)`
	`2338`	`+ catch (System.StackOverflowException ex)`
`2316`	`2339`	`{`
`2317`		`- _activeConnection.Abort(e);`
	`2340`	`+ _activeConnection.Abort(ex);`
`2318`	`2341`	`throw;`
`2319`	`2342`	`}`
`2320`		`- catch (System.StackOverflowException e)`
	`2343`	`+ catch (System.Threading.ThreadAbortException ex)`
`2321`	`2344`	`{`
`2322`		`- _activeConnection.Abort(e);`
	`2345`	`+ _activeConnection.Abort(ex);`
	`2346`	`+ SqlInternalConnection.BestEffortCleanup(bestEffortCleanupTarget);`
`2323`	`2347`	`throw;`
`2324`	`2348`	`}`
`2325`		`- catch (System.Threading.ThreadAbortException e)`
	`2349`	`+ catch (Exception ex)`
`2326`	`2350`	`{`
`2327`		`- _activeConnection.Abort(e);`
`2328`		`- SqlInternalConnection.BestEffortCleanup(bestEffortCleanupTarget);`
	`2351`	`+ if (ex is SqlException sqlException)`
	`2352`	`+ {`
	`2353`	`+ sqlExceptionNumber = sqlException.Number;`
	`2354`	`+ }`
	`2355`	`+`
	`2356`	`+ e = ex;`
`2329`	`2357`	`throw;`
`2330`	`2358`	`}`
`2331`	`2359`	`finally`
`2332`	`2360`	`{`
`2333`	`2361`	`SqlStatistics.StopTimer(statistics);`
`2334`	`2362`	`WriteEndExecuteEvent(success, sqlExceptionNumber, synchronous: true);`
	`2363`	`+ if (e != null)`
	`2364`	`+ {`
	`2365`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);`
	`2366`	`+ }`
	`2367`	`+ else`
	`2368`	`+ {`
	`2369`	`+ s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);`
	`2370`	`+ }`
`2335`	`2371`	`}`
`2336`	`2372`	`}`
`2337`	`2373`	`}`
`@@ -2433,10 +2469,18 @@ private void CleanupExecuteReaderAsync(Task<SqlDataReader> task, TaskCompletionS`
`2433`	`2469`	`if (task.IsFaulted)`
`2434`	`2470`	`{`
`2435`	`2471`	`Exception e = task.Exception.InnerException;`
	`2472`	`+ if (!_parentOperationStarted)`
	`2473`	`+ {`
	`2474`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);`
	`2475`	`+ }`
`2436`	`2476`	`source.SetException(e);`
`2437`	`2477`	`}`
`2438`	`2478`	`else`
`2439`	`2479`	`{`
	`2480`	`+ if (!_parentOperationStarted)`
	`2481`	`+ {`
	`2482`	`+ s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);`
	`2483`	`+ }`
`2440`	`2484`	`if (task.IsCanceled)`
`2441`	`2485`	`{`
`2442`	`2486`	`source.SetCanceled();`
`@@ -2832,7 +2876,7 @@ private Task<int> InternalExecuteNonQueryAsync(CancellationToken cancellationTok`
`2832`	`2876`	`{`
`2833`	`2877`	`SqlClientEventSource.Log.TryCorrelationTraceEvent("SqlCommand.InternalExecuteNonQueryAsync \| API \| Correlation \| Object Id {0}, Activity Id {1}, Client Connection Id {2}, Command Text '{3}'", ObjectID, ActivityCorrelator.Current, Connection?.ClientConnectionId, CommandText);`
`2834`	`2878`	`SqlConnection.ExecutePermission.Demand();`
`2835`		`- Guid operationId = Guid.Empty;`
	`2879`	`+ Guid operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);`
`2836`	`2880`
`2837`	`2881`	`// connection can be used as state in RegisterForConnectionCloseNotification continuation`
`2838`	`2882`	`// to avoid an allocation so use it as the state value if possible but it can be changed if`
`@@ -2885,6 +2929,7 @@ private Task<int> InternalExecuteNonQueryAsync(CancellationToken cancellationTok`
`2885`	`2929`	`}`
`2886`	`2930`	`catch (Exception e)`
`2887`	`2931`	`{`
	`2932`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);`
`2888`	`2933`	`source.SetException(e);`
`2889`	`2934`	`context.Dispose();`
`2890`	`2935`	`}`
`@@ -2897,6 +2942,7 @@ private void CleanupAfterExecuteNonQueryAsync(Task<int> task, TaskCompletionSour`
`2897`	`2942`	`if (task.IsFaulted)`
`2898`	`2943`	`{`
`2899`	`2944`	`Exception e = task.Exception.InnerException;`
	`2945`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);`
`2900`	`2946`	`source.SetException(e);`
`2901`	`2947`	`}`
`2902`	`2948`	`else`
`@@ -2909,6 +2955,7 @@ private void CleanupAfterExecuteNonQueryAsync(Task<int> task, TaskCompletionSour`
`2909`	`2955`	`{`
`2910`	`2956`	`source.SetResult(task.Result);`
`2911`	`2957`	`}`
	`2958`	`+ s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);`
`2912`	`2959`	`}`
`2913`	`2960`	`}`
`2914`	`2961`
`@@ -2960,6 +3007,10 @@ private Task<SqlDataReader> InternalExecuteReaderAsync(CommandBehavior behavior,`
`2960`	`3007`	`SqlClientEventSource.Log.TryTraceEvent("SqlCommand.InternalExecuteReaderAsync \| API> {0}, Client Connection Id {1}, Command Text = '{2}'", ObjectID, Connection?.ClientConnectionId, CommandText);`
`2961`	`3008`	`SqlConnection.ExecutePermission.Demand();`
`2962`	`3009`	`Guid operationId = default(Guid);`
	`3010`	`+ if (!_parentOperationStarted)`
	`3011`	`+ {`
	`3012`	`+ operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);`
	`3013`	`+ }`
`2963`	`3014`
`2964`	`3015`	`// connection can be used as state in RegisterForConnectionCloseNotification continuation`
`2965`	`3016`	`// to avoid an allocation so use it as the state value if possible but it can be changed if`
`@@ -3021,6 +3072,11 @@ private Task<SqlDataReader> InternalExecuteReaderAsync(CommandBehavior behavior,`
`3021`	`3072`	`}`
`3022`	`3073`	`catch (Exception e)`
`3023`	`3074`	`{`
	`3075`	`+ if (!_parentOperationStarted)`
	`3076`	`+ {`
	`3077`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);`
	`3078`	`+ }`
	`3079`	`+`
`3024`	`3080`	`source.SetException(e);`
`3025`	`3081`	`context?.Dispose();`
`3026`	`3082`	`}`
`@@ -3059,6 +3115,9 @@ public override Task<object> ExecuteScalarAsync(CancellationToken cancellationTo`
`3059`	`3115`
`3060`	`3116`	`private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationToken)`
`3061`	`3117`	`{`
	`3118`	`+ _parentOperationStarted = true;`
	`3119`	`+ Guid operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);`
	`3120`	`+`
`3062`	`3121`	`return ExecuteReaderAsync(cancellationToken).ContinueWith((executeTask) =>`
`3063`	`3122`	`{`
`3064`	`3123`	`TaskCompletionSource<object> source = new TaskCompletionSource<object>();`
`@@ -3068,6 +3127,7 @@ private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationTo`
`3068`	`3127`	`}`
`3069`	`3128`	`else if (executeTask.IsFaulted)`
`3070`	`3129`	`{`
	`3130`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, executeTask.Exception.InnerException);`
`3071`	`3131`	`source.SetException(executeTask.Exception.InnerException);`
`3072`	`3132`	`}`
`3073`	`3133`	`else`
`@@ -3086,6 +3146,7 @@ private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationTo`
`3086`	`3146`	`else if (readTask.IsFaulted)`
`3087`	`3147`	`{`
`3088`	`3148`	`reader.Dispose();`
	`3149`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, readTask.Exception.InnerException);`
`3089`	`3150`	`source.SetException(readTask.Exception.InnerException);`
`3090`	`3151`	`}`
`3091`	`3152`	`else`
`@@ -3113,10 +3174,12 @@ private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationTo`
`3113`	`3174`	`}`
`3114`	`3175`	`if (exception != null)`
`3115`	`3176`	`{`
	`3177`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, exception);`
`3116`	`3178`	`source.SetException(exception);`
`3117`	`3179`	`}`
`3118`	`3180`	`else`
`3119`	`3181`	`{`
	`3182`	`+ s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);`
`3120`	`3183`	`source.SetResult(result);`
`3121`	`3184`	`}`
`3122`	`3185`	`}`
`@@ -3130,6 +3193,7 @@ private Task<object> InternalExecuteScalarAsync(CancellationToken cancellationTo`
`3130`	`3193`	`TaskScheduler.Default`
`3131`	`3194`	`);`
`3132`	`3195`	`}`
	`3196`	`+ _parentOperationStarted = false;`
`3133`	`3197`	`return source.Task;`
`3134`	`3198`	`}, TaskScheduler.Default).Unwrap();`
`3135`	`3199`	`}`
`@@ -3154,7 +3218,7 @@ private Task<XmlReader> InternalExecuteXmlReaderAsync(CancellationToken cancella`
`3154`	`3218`	`{`
`3155`	`3219`	`SqlClientEventSource.Log.TryCorrelationTraceEvent("SqlCommand.InternalExecuteXmlReaderAsync \| API \| Correlation \| Object Id {0}, Activity Id {1}, Client Connection Id {2}, Command Text '{3}'", ObjectID, ActivityCorrelator.Current, Connection?.ClientConnectionId, CommandText);`
`3156`	`3220`	`SqlConnection.ExecutePermission.Demand();`
`3157`		`- Guid operationId = Guid.Empty;`
	`3221`	`+ Guid operationId = s_diagnosticListener.WriteCommandBefore(this, _transaction);`
`3158`	`3222`
`3159`	`3223`	`// connection can be used as state in RegisterForConnectionCloseNotification continuation`
`3160`	`3224`	`// to avoid an allocation so use it as the state value if possible but it can be changed if`
`@@ -3214,6 +3278,7 @@ private Task<XmlReader> InternalExecuteXmlReaderAsync(CancellationToken cancella`
`3214`	`3278`	`}`
`3215`	`3279`	`catch (Exception e)`
`3216`	`3280`	`{`
	`3281`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);`
`3217`	`3282`	`source.SetException(e);`
`3218`	`3283`	`}`
`3219`	`3284`
`@@ -3225,6 +3290,7 @@ private void CleanupAfterExecuteXmlReaderAsync(Task<XmlReader> task, TaskComplet`
`3225`	`3290`	`if (task.IsFaulted)`
`3226`	`3291`	`{`
`3227`	`3292`	`Exception e = task.Exception.InnerException;`
	`3293`	`+ s_diagnosticListener.WriteCommandError(operationId, this, _transaction, e);`
`3228`	`3294`	`source.SetException(e);`
`3229`	`3295`	`}`
`3230`	`3296`	`else`
`@@ -3237,6 +3303,7 @@ private void CleanupAfterExecuteXmlReaderAsync(Task<XmlReader> task, TaskComplet`
`3237`	`3303`	`{`
`3238`	`3304`	`source.SetResult(task.Result);`
`3239`	`3305`	`}`
	`3306`	`+ s_diagnosticListener.WriteCommandAfter(operationId, this, _transaction);`
`3240`	`3307`	`}`
`3241`	`3308`	`}`
`3242`	`3309`