Simplify usage of logging in transports

gfoidl · gfoidl · commit 43d331a7d5e1 · 2021-04-06T17:53:38.000+02:00
diff --git a/src/Servers/Kestrel/Transport.Quic/src/Internal/IQuicTrace.cs b/src/Servers/Kestrel/Transport.Quic/src/Internal/IQuicTrace.cs
@@ -2,19 +2,20 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using Microsoft.AspNetCore.Connections;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.AspNetCore.Server.Kestrel.Transport.Experimental.Quic.Internal
 {
     internal interface IQuicTrace : ILogger
     {
-        void AcceptedConnection(string connectionId);
-        void AcceptedStream(string streamId);
-        void ConnectionError(string connectionId, Exception ex);
-        void StreamError(string streamId, Exception ex);
-        void StreamPause(string streamId);
-        void StreamResume(string streamId);
-        void StreamShutdownWrite(string streamId, string reason);
-        void StreamAbort(string streamId, string reason);
+        void AcceptedConnection(BaseConnectionContext connection);
+        void AcceptedStream(QuicStreamContext streamContext);
+        void ConnectionError(BaseConnectionContext connection, Exception ex);
+        void StreamError(QuicStreamContext streamContext, Exception ex);
+        void StreamPause(QuicStreamContext streamContext);
+        void StreamResume(QuicStreamContext streamContext);
+        void StreamShutdownWrite(QuicStreamContext streamContext, string reason);
+        void StreamAbort(QuicStreamContext streamContext, string reason);
     }
 }
diff --git a/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicConnectionContext.cs b/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicConnectionContext.cs
@@ -32,10 +32,7 @@ public QuicConnectionContext(QuicConnection connection, QuicTransportContext con
             Features.Set<ITlsConnectionFeature>(new FakeTlsConnectionFeature());
             Features.Set<IProtocolErrorCodeFeature>(this);
 
-            if (_log.IsEnabled(LogLevel.Debug))
-            {
-                _log.AcceptedConnection(ConnectionId);
-            }
+            _log.AcceptedConnection(this);
         }
 
         public ValueTask<ConnectionContext> StartUnidirectionalStreamAsync()
diff --git a/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicStreamContext.cs b/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicStreamContext.cs
@@ -131,10 +131,7 @@ private async Task DoReceive()
             {
                 // This is unexpected.
                 error = ex;
-                if (_log.IsEnabled(LogLevel.Debug))
-                {
-                    _log.StreamError(ConnectionId, error);
-                }
+                _log.StreamError(this, error);
             }
             finally
             {
@@ -167,16 +164,16 @@ private async Task ProcessReceives()
 
                 var paused = !flushTask.IsCompleted;
 
-                if (paused && _log.IsEnabled(LogLevel.Debug))
+                if (paused)
                 {
-                    _log.StreamPause(ConnectionId);
+                    _log.StreamPause(this);
                 }
 
                 var result = await flushTask;
 
-                if (paused && _log.IsEnabled(LogLevel.Debug))
+                if (paused)
                 {
-                    _log.StreamResume(ConnectionId);
+                    _log.StreamResume(this);
                 }
 
                 if (result.IsCompleted || result.IsCanceled)
@@ -237,10 +234,7 @@ private async Task DoSend()
             {
                 shutdownReason = ex;
                 unexpectedError = ex;
-                if (_log.IsEnabled(LogLevel.Debug))
-                {
-                    _log.ConnectionError(ConnectionId, unexpectedError);
-                }
+                _log.ConnectionError(this, unexpectedError);
             }
             finally
             {
@@ -297,10 +291,7 @@ public override void Abort(ConnectionAbortedException abortReason)
 
             _aborted = true;
 
-            if (_log.IsEnabled(LogLevel.Debug))
-            {
-                _log.StreamAbort(ConnectionId, abortReason.Message);
-            }
+            _log.StreamAbort(this, abortReason.Message);
 
             lock (_shutdownLock)
             {
@@ -320,11 +311,8 @@ private async ValueTask ShutdownWrite(Exception? shutdownReason)
                 {
                     // TODO: Exception is always allocated. Consider only allocating if receive hasn't completed.
                     _shutdownReason = shutdownReason ?? new ConnectionAbortedException("The Quic transport's send loop completed gracefully.");
+                    _log.StreamShutdownWrite(this, _shutdownReason.Message);
 
-                    if (_log.IsEnabled(LogLevel.Debug))
-                    {
-                        _log.StreamShutdownWrite(ConnectionId, _shutdownReason.Message);
-                    }
                     _stream.Shutdown();
                 }
 
diff --git a/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicTrace.cs b/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicTrace.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using Microsoft.AspNetCore.Connections;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.AspNetCore.Server.Kestrel.Transport.Experimental.Quic.Internal
@@ -11,7 +12,7 @@ internal class QuicTrace : IQuicTrace
         private static readonly Action<ILogger, string, Exception?> _acceptedConnection =
             LoggerMessage.Define<string>(LogLevel.Debug, new EventId(1, "AcceptedConnection"), @"Connection id ""{ConnectionId}"" accepted.", skipEnabledCheck: true);
         private static readonly Action<ILogger, string, Exception?> _acceptedStream =
-            LoggerMessage.Define<string>(LogLevel.Debug, new EventId(2, "AcceptedStream"), @"Stream id ""{ConnectionId}"" accepted.");
+            LoggerMessage.Define<string>(LogLevel.Debug, new EventId(2, "AcceptedStream"), @"Stream id ""{ConnectionId}"" accepted.", skipEnabledCheck: true);
         private static readonly Action<ILogger, string, Exception?> _connectionError =
             LoggerMessage.Define<string>(LogLevel.Debug, new EventId(3, "ConnectionError"), @"Connection id ""{ConnectionId}"" unexpected error.", skipEnabledCheck: true);
         private static readonly Action<ILogger, string, Exception?> _streamError =
@@ -39,44 +40,60 @@ public QuicTrace(ILogger logger)
         public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
             => _logger.Log(logLevel, eventId, state, exception, formatter);
 
-        public void AcceptedConnection(string connectionId)
+        public void AcceptedConnection(BaseConnectionContext connection)
         {
-            _acceptedConnection(_logger, connectionId, null);
+            if (!_logger.IsEnabled(LogLevel.Debug)) return;
+
+            _acceptedConnection(_logger, connection.ConnectionId, null);
         }
 
-        public void AcceptedStream(string streamId)
+        public void AcceptedStream(QuicStreamContext streamContext)
         {
-            _acceptedStream(_logger, streamId, null);
+            if (!_logger.IsEnabled(LogLevel.Debug)) return;
+
+            _acceptedStream(_logger, streamContext.ConnectionId, null);
         }
 
-        public void ConnectionError(string connectionId, Exception ex)
+        public void ConnectionError(BaseConnectionContext connection, Exception ex)
         {
-            _connectionError(_logger, connectionId, ex);
+            if (!_logger.IsEnabled(LogLevel.Debug)) return;
+
+            _connectionError(_logger, connection.ConnectionId, ex);
         }
 
-        public void StreamError(string streamId, Exception ex)
+        public void StreamError(QuicStreamContext streamContext, Exception ex)
         {
-            _streamError(_logger, streamId, ex);
+            if (!_logger.IsEnabled(LogLevel.Debug)) return;
+
+            _streamError(_logger, streamContext.ConnectionId, ex);
         }
 
-        public void StreamPause(string streamId)
+        public void StreamPause(QuicStreamContext streamContext)
         {
-            _streamPause(_logger, streamId, null);
+            if (!_logger.IsEnabled(LogLevel.Debug)) return;
+
+            _streamPause(_logger, streamContext.ConnectionId, null);
         }
 
-        public void StreamResume(string streamId)
+        public void StreamResume(QuicStreamContext streamContext)
         {
-            _streamResume(_logger, streamId, null);
+            if (!_logger.IsEnabled(LogLevel.Debug)) return;
+
+            _streamResume(_logger, streamContext.ConnectionId, null);
         }
 
-        public void StreamShutdownWrite(string streamId, string reason)
+        public void StreamShutdownWrite(QuicStreamContext streamContext, string reason)
         {
-            _streamShutdownWrite(_logger, streamId, reason, null);
+            if (!_logger.IsEnabled(LogLevel.Debug)) return;
+
+            _streamShutdownWrite(_logger, streamContext.ConnectionId, reason, null);
         }
 
-        public void StreamAbort(string streamId, string reason)
+        public void StreamAbort(QuicStreamContext streamContext, string reason)
         {
-            _streamAborted(_logger, streamId, reason, null);
+            if (!_logger.IsEnabled(LogLevel.Debug)) return;
+
+            _streamAborted(_logger, streamContext.ConnectionId, reason, null);
         }
     }
 }
diff --git a/src/Servers/Kestrel/Transport.Sockets/src/Internal/ISocketsTrace.cs b/src/Servers/Kestrel/Transport.Sockets/src/Internal/ISocketsTrace.cs
@@ -8,16 +8,17 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets.Internal
 {
     internal interface ISocketsTrace : ILogger
     {
-        void ConnectionReadFin(string connectionId);
+        void ConnectionReadFin(SocketConnection connection);
 
-        void ConnectionWriteFin(string connectionId, string reason);
+        void ConnectionWriteFin(SocketConnection connection, string reason);
 
-        void ConnectionError(string connectionId, Exception ex);
+        void ConnectionError(SocketConnection connection, Exception ex);
 
         void ConnectionReset(string connectionId);
+        void ConnectionReset(SocketConnection connection);
 
-        void ConnectionPause(string connectionId);
+        void ConnectionPause(SocketConnection connection);
 
-        void ConnectionResume(string connectionId);
+        void ConnectionResume(SocketConnection connection);
     }
 }
diff --git a/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketConnection.cs b/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketConnection.cs
@@ -156,10 +156,7 @@ private async Task DoReceive()
                     if (bytesReceived == 0)
                     {
                         // FIN
-                        if (_trace.IsEnabled(LogLevel.Debug))
-                        {
-                            _trace.ConnectionReadFin(ConnectionId);
-                        }
+                        _trace.ConnectionReadFin(this);
                         break;
                     }
 
@@ -169,16 +166,16 @@ private async Task DoReceive()
 
                     var paused = !flushTask.IsCompleted;
 
-                    if (paused && _trace.IsEnabled(LogLevel.Debug))
+                    if (paused)
                     {
-                        _trace.ConnectionPause(ConnectionId);
+                        _trace.ConnectionPause(this);
                     }
 
                     var result = await flushTask;
 
-                    if (paused && _trace.IsEnabled(LogLevel.Debug))
+                    if (paused)
                     {
-                        _trace.ConnectionResume(ConnectionId);
+                        _trace.ConnectionResume(this);
                     }
 
                     if (result.IsCompleted || result.IsCanceled)
@@ -197,7 +194,7 @@ private async Task DoReceive()
                 // Both logs will have the same ConnectionId. I don't think it's worthwhile to lock just to avoid this.
                 if (!_socketDisposed)
                 {
-                    _trace.ConnectionReset(ConnectionId);
+                    _trace.ConnectionReset(this);
                 }
             }
             catch (Exception ex)
@@ -207,20 +204,17 @@ private async Task DoReceive()
                 // This exception should always be ignored because _shutdownReason should be set.
                 error = ex;
 
-                if (!_socketDisposed && _trace.IsEnabled(LogLevel.Debug))
+                if (!_socketDisposed)
                 {
                     // This is unexpected if the socket hasn't been disposed yet.
-                    _trace.ConnectionError(ConnectionId, error);
+                    _trace.ConnectionError(this, error);
                 }
             }
             catch (Exception ex)
             {
                 // This is unexpected.
                 error = ex;
-                if (_trace.IsEnabled(LogLevel.Debug))
-                {
-                    _trace.ConnectionError(ConnectionId, error);
-                }
+                _trace.ConnectionError(this, error);
             }
             finally
             {
@@ -271,10 +265,7 @@ private async Task DoSend()
             catch (SocketException ex) when (IsConnectionResetError(ex.SocketErrorCode))
             {
                 shutdownReason = new ConnectionResetException(ex.Message, ex);
-                if (_trace.IsEnabled(LogLevel.Debug))
-                {
-                    _trace.ConnectionReset(ConnectionId);
-                }
+                _trace.ConnectionReset(this);
             }
             catch (Exception ex)
                 when ((ex is SocketException socketEx && IsConnectionAbortError(socketEx.SocketErrorCode)) ||
@@ -287,10 +278,7 @@ private async Task DoSend()
             {
                 shutdownReason = ex;
                 unexpectedError = ex;
-                if (_trace.IsEnabled(LogLevel.Debug))
-                {
-                    _trace.ConnectionError(ConnectionId, unexpectedError);
-                }
+                _trace.ConnectionError(this, unexpectedError);
             }
             finally
             {
@@ -342,11 +330,7 @@ private void Shutdown(Exception? shutdownReason)
                 // ever observe the nondescript ConnectionAbortedException except for connection middleware attempting
                 // to half close the connection which is currently unsupported.
                 _shutdownReason = shutdownReason ?? new ConnectionAbortedException("The Socket transport's send loop completed gracefully.");
-
-                if (_trace.IsEnabled(LogLevel.Debug))
-                {
-                    _trace.ConnectionWriteFin(ConnectionId, _shutdownReason.Message);
-                }
+                _trace.ConnectionWriteFin(this, _shutdownReason.Message);
 
                 try
                 {
diff --git a/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketsTrace.cs b/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketsTrace.cs
diff --git a/src/Servers/Kestrel/shared/TransportConnection.cs b/src/Servers/Kestrel/shared/TransportConnection.cs
diff --git a/src/Servers/Kestrel/shared/TransportMultiplexedConnection.cs b/src/Servers/Kestrel/shared/TransportMultiplexedConnection.cs

Original file line number	Diff line number	Diff line change
`@@ -131,10 +131,7 @@ private async Task DoReceive()`
`131`	`131`	`{`
`132`	`132`	`// This is unexpected.`
`133`	`133`	`error = ex;`
`134`		`- if (_log.IsEnabled(LogLevel.Debug))`
`135`		`- {`
`136`		`- _log.StreamError(ConnectionId, error);`
`137`		`- }`
	`134`	`+ _log.StreamError(this, error);`
`138`	`135`	`}`
`139`	`136`	`finally`
`140`	`137`	`{`
`@@ -167,16 +164,16 @@ private async Task ProcessReceives()`
`167`	`164`
`168`	`165`	`var paused = !flushTask.IsCompleted;`
`169`	`166`
`170`		`- if (paused && _log.IsEnabled(LogLevel.Debug))`
	`167`	`+ if (paused)`
`171`	`168`	`{`
`172`		`- _log.StreamPause(ConnectionId);`
	`169`	`+ _log.StreamPause(this);`
`173`	`170`	`}`
`174`	`171`
`175`	`172`	`var result = await flushTask;`
`176`	`173`
`177`		`- if (paused && _log.IsEnabled(LogLevel.Debug))`
	`174`	`+ if (paused)`
`178`	`175`	`{`
`179`		`- _log.StreamResume(ConnectionId);`
	`176`	`+ _log.StreamResume(this);`
`180`	`177`	`}`
`181`	`178`
`182`	`179`	`if (result.IsCompleted \|\| result.IsCanceled)`
`@@ -237,10 +234,7 @@ private async Task DoSend()`
`237`	`234`	`{`
`238`	`235`	`shutdownReason = ex;`
`239`	`236`	`unexpectedError = ex;`
`240`		`- if (_log.IsEnabled(LogLevel.Debug))`
`241`		`- {`
`242`		`- _log.ConnectionError(ConnectionId, unexpectedError);`
`243`		`- }`
	`237`	`+ _log.ConnectionError(this, unexpectedError);`
`244`	`238`	`}`
`245`	`239`	`finally`
`246`	`240`	`{`
`@@ -297,10 +291,7 @@ public override void Abort(ConnectionAbortedException abortReason)`
`297`	`291`
`298`	`292`	`_aborted = true;`
`299`	`293`
`300`		`- if (_log.IsEnabled(LogLevel.Debug))`
`301`		`- {`
`302`		`- _log.StreamAbort(ConnectionId, abortReason.Message);`
`303`		`- }`
	`294`	`+ _log.StreamAbort(this, abortReason.Message);`
`304`	`295`
`305`	`296`	`lock (_shutdownLock)`
`306`	`297`	`{`
`@@ -320,11 +311,8 @@ private async ValueTask ShutdownWrite(Exception? shutdownReason)`
`320`	`311`	`{`
`321`	`312`	`// TODO: Exception is always allocated. Consider only allocating if receive hasn't completed.`
`322`	`313`	`_shutdownReason = shutdownReason ?? new ConnectionAbortedException("The Quic transport's send loop completed gracefully.");`
	`314`	`+ _log.StreamShutdownWrite(this, _shutdownReason.Message);`
`323`	`315`
`324`		`- if (_log.IsEnabled(LogLevel.Debug))`
`325`		`- {`
`326`		`- _log.StreamShutdownWrite(ConnectionId, _shutdownReason.Message);`
`327`		`- }`
`328`	`316`	`_stream.Shutdown();`
`329`	`317`	`}`
`330`	`318`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.`
`3`	`3`
`4`	`4`	`using System;`
	`5`	`+using Microsoft.AspNetCore.Connections;`
`5`	`6`	`using Microsoft.Extensions.Logging;`
`6`	`7`
`7`	`8`	`namespace Microsoft.AspNetCore.Server.Kestrel.Transport.Experimental.Quic.Internal`
`@@ -11,7 +12,7 @@ internal class QuicTrace : IQuicTrace`
`11`	`12`	`private static readonly Action<ILogger, string, Exception?> _acceptedConnection =`
`12`	`13`	`LoggerMessage.Define<string>(LogLevel.Debug, new EventId(1, "AcceptedConnection"), @"Connection id ""{ConnectionId}"" accepted.", skipEnabledCheck: true);`
`13`	`14`	`private static readonly Action<ILogger, string, Exception?> _acceptedStream =`
`14`		`- LoggerMessage.Define<string>(LogLevel.Debug, new EventId(2, "AcceptedStream"), @"Stream id ""{ConnectionId}"" accepted.");`
	`15`	`+ LoggerMessage.Define<string>(LogLevel.Debug, new EventId(2, "AcceptedStream"), @"Stream id ""{ConnectionId}"" accepted.", skipEnabledCheck: true);`
`15`	`16`	`private static readonly Action<ILogger, string, Exception?> _connectionError =`
`16`	`17`	`LoggerMessage.Define<string>(LogLevel.Debug, new EventId(3, "ConnectionError"), @"Connection id ""{ConnectionId}"" unexpected error.", skipEnabledCheck: true);`
`17`	`18`	`private static readonly Action<ILogger, string, Exception?> _streamError =`
`@@ -39,44 +40,60 @@ public QuicTrace(ILogger logger)`
`39`	`40`	`public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)`
`40`	`41`	`=> _logger.Log(logLevel, eventId, state, exception, formatter);`
`41`	`42`
`42`		`- public void AcceptedConnection(string connectionId)`
	`43`	`+ public void AcceptedConnection(BaseConnectionContext connection)`
`43`	`44`	`{`
`44`		`- _acceptedConnection(_logger, connectionId, null);`
	`45`	`+ if (!_logger.IsEnabled(LogLevel.Debug)) return;`
	`46`	`+`
	`47`	`+ _acceptedConnection(_logger, connection.ConnectionId, null);`
`45`	`48`	`}`
`46`	`49`
`47`		`- public void AcceptedStream(string streamId)`
	`50`	`+ public void AcceptedStream(QuicStreamContext streamContext)`
`48`	`51`	`{`
`49`		`- _acceptedStream(_logger, streamId, null);`
	`52`	`+ if (!_logger.IsEnabled(LogLevel.Debug)) return;`
	`53`	`+`
	`54`	`+ _acceptedStream(_logger, streamContext.ConnectionId, null);`
`50`	`55`	`}`
`51`	`56`
`52`		`- public void ConnectionError(string connectionId, Exception ex)`
	`57`	`+ public void ConnectionError(BaseConnectionContext connection, Exception ex)`
`53`	`58`	`{`
`54`		`- _connectionError(_logger, connectionId, ex);`
	`59`	`+ if (!_logger.IsEnabled(LogLevel.Debug)) return;`
	`60`	`+`
	`61`	`+ _connectionError(_logger, connection.ConnectionId, ex);`
`55`	`62`	`}`
`56`	`63`
`57`		`- public void StreamError(string streamId, Exception ex)`
	`64`	`+ public void StreamError(QuicStreamContext streamContext, Exception ex)`
`58`	`65`	`{`
`59`		`- _streamError(_logger, streamId, ex);`
	`66`	`+ if (!_logger.IsEnabled(LogLevel.Debug)) return;`
	`67`	`+`
	`68`	`+ _streamError(_logger, streamContext.ConnectionId, ex);`
`60`	`69`	`}`
`61`	`70`
`62`		`- public void StreamPause(string streamId)`
	`71`	`+ public void StreamPause(QuicStreamContext streamContext)`
`63`	`72`	`{`
`64`		`- _streamPause(_logger, streamId, null);`
	`73`	`+ if (!_logger.IsEnabled(LogLevel.Debug)) return;`
	`74`	`+`
	`75`	`+ _streamPause(_logger, streamContext.ConnectionId, null);`
`65`	`76`	`}`
`66`	`77`
`67`		`- public void StreamResume(string streamId)`
	`78`	`+ public void StreamResume(QuicStreamContext streamContext)`
`68`	`79`	`{`
`69`		`- _streamResume(_logger, streamId, null);`
	`80`	`+ if (!_logger.IsEnabled(LogLevel.Debug)) return;`
	`81`	`+`
	`82`	`+ _streamResume(_logger, streamContext.ConnectionId, null);`
`70`	`83`	`}`
`71`	`84`
`72`		`- public void StreamShutdownWrite(string streamId, string reason)`
	`85`	`+ public void StreamShutdownWrite(QuicStreamContext streamContext, string reason)`
`73`	`86`	`{`
`74`		`- _streamShutdownWrite(_logger, streamId, reason, null);`
	`87`	`+ if (!_logger.IsEnabled(LogLevel.Debug)) return;`
	`88`	`+`
	`89`	`+ _streamShutdownWrite(_logger, streamContext.ConnectionId, reason, null);`
`75`	`90`	`}`
`76`	`91`
`77`		`- public void StreamAbort(string streamId, string reason)`
	`92`	`+ public void StreamAbort(QuicStreamContext streamContext, string reason)`
`78`	`93`	`{`
`79`		`- _streamAborted(_logger, streamId, reason, null);`
	`94`	`+ if (!_logger.IsEnabled(LogLevel.Debug)) return;`
	`95`	`+`
	`96`	`+ _streamAborted(_logger, streamContext.ConnectionId, reason, null);`
`80`	`97`	`}`
`81`	`98`	`}`
`82`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,16 +8,17 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets.Internal`
`8`	`8`	`{`
`9`	`9`	`internal interface ISocketsTrace : ILogger`
`10`	`10`	`{`
`11`		`- void ConnectionReadFin(string connectionId);`
	`11`	`+ void ConnectionReadFin(SocketConnection connection);`
`12`	`12`
`13`		`- void ConnectionWriteFin(string connectionId, string reason);`
	`13`	`+ void ConnectionWriteFin(SocketConnection connection, string reason);`
`14`	`14`
`15`		`- void ConnectionError(string connectionId, Exception ex);`
	`15`	`+ void ConnectionError(SocketConnection connection, Exception ex);`
`16`	`16`
`17`	`17`	`void ConnectionReset(string connectionId);`
	`18`	`+ void ConnectionReset(SocketConnection connection);`
`18`	`19`
`19`		`- void ConnectionPause(string connectionId);`
	`20`	`+ void ConnectionPause(SocketConnection connection);`
`20`	`21`
`21`		`- void ConnectionResume(string connectionId);`
	`22`	`+ void ConnectionResume(SocketConnection connection);`
`22`	`23`	`}`
`23`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -156,10 +156,7 @@ private async Task DoReceive()`
`156`	`156`	`if (bytesReceived == 0)`
`157`	`157`	`{`
`158`	`158`	`// FIN`
`159`		`- if (_trace.IsEnabled(LogLevel.Debug))`
`160`		`- {`
`161`		`- _trace.ConnectionReadFin(ConnectionId);`
`162`		`- }`
	`159`	`+ _trace.ConnectionReadFin(this);`
`163`	`160`	`break;`
`164`	`161`	`}`
`165`	`162`
`@@ -169,16 +166,16 @@ private async Task DoReceive()`
`169`	`166`
`170`	`167`	`var paused = !flushTask.IsCompleted;`
`171`	`168`
`172`		`- if (paused && _trace.IsEnabled(LogLevel.Debug))`
	`169`	`+ if (paused)`
`173`	`170`	`{`
`174`		`- _trace.ConnectionPause(ConnectionId);`
	`171`	`+ _trace.ConnectionPause(this);`
`175`	`172`	`}`
`176`	`173`
`177`	`174`	`var result = await flushTask;`
`178`	`175`
`179`		`- if (paused && _trace.IsEnabled(LogLevel.Debug))`
	`176`	`+ if (paused)`
`180`	`177`	`{`
`181`		`- _trace.ConnectionResume(ConnectionId);`
	`178`	`+ _trace.ConnectionResume(this);`
`182`	`179`	`}`
`183`	`180`
`184`	`181`	`if (result.IsCompleted \|\| result.IsCanceled)`
`@@ -197,7 +194,7 @@ private async Task DoReceive()`
`197`	`194`	`// Both logs will have the same ConnectionId. I don't think it's worthwhile to lock just to avoid this.`
`198`	`195`	`if (!_socketDisposed)`
`199`	`196`	`{`
`200`		`- _trace.ConnectionReset(ConnectionId);`
	`197`	`+ _trace.ConnectionReset(this);`
`201`	`198`	`}`
`202`	`199`	`}`
`203`	`200`	`catch (Exception ex)`
`@@ -207,20 +204,17 @@ private async Task DoReceive()`
`207`	`204`	`// This exception should always be ignored because _shutdownReason should be set.`
`208`	`205`	`error = ex;`
`209`	`206`
`210`		`- if (!_socketDisposed && _trace.IsEnabled(LogLevel.Debug))`
	`207`	`+ if (!_socketDisposed)`
`211`	`208`	`{`
`212`	`209`	`// This is unexpected if the socket hasn't been disposed yet.`
`213`		`- _trace.ConnectionError(ConnectionId, error);`
	`210`	`+ _trace.ConnectionError(this, error);`
`214`	`211`	`}`
`215`	`212`	`}`
`216`	`213`	`catch (Exception ex)`
`217`	`214`	`{`
`218`	`215`	`// This is unexpected.`
`219`	`216`	`error = ex;`
`220`		`- if (_trace.IsEnabled(LogLevel.Debug))`
`221`		`- {`
`222`		`- _trace.ConnectionError(ConnectionId, error);`
`223`		`- }`
	`217`	`+ _trace.ConnectionError(this, error);`
`224`	`218`	`}`
`225`	`219`	`finally`
`226`	`220`	`{`
`@@ -271,10 +265,7 @@ private async Task DoSend()`
`271`	`265`	`catch (SocketException ex) when (IsConnectionResetError(ex.SocketErrorCode))`
`272`	`266`	`{`
`273`	`267`	`shutdownReason = new ConnectionResetException(ex.Message, ex);`
`274`		`- if (_trace.IsEnabled(LogLevel.Debug))`
`275`		`- {`
`276`		`- _trace.ConnectionReset(ConnectionId);`
`277`		`- }`
	`268`	`+ _trace.ConnectionReset(this);`
`278`	`269`	`}`
`279`	`270`	`catch (Exception ex)`
`280`	`271`	`when ((ex is SocketException socketEx && IsConnectionAbortError(socketEx.SocketErrorCode)) \|\|`
`@@ -287,10 +278,7 @@ private async Task DoSend()`
`287`	`278`	`{`
`288`	`279`	`shutdownReason = ex;`
`289`	`280`	`unexpectedError = ex;`
`290`		`- if (_trace.IsEnabled(LogLevel.Debug))`
`291`		`- {`
`292`		`- _trace.ConnectionError(ConnectionId, unexpectedError);`
`293`		`- }`
	`281`	`+ _trace.ConnectionError(this, unexpectedError);`
`294`	`282`	`}`
`295`	`283`	`finally`
`296`	`284`	`{`
`@@ -342,11 +330,7 @@ private void Shutdown(Exception? shutdownReason)`
`342`	`330`	`// ever observe the nondescript ConnectionAbortedException except for connection middleware attempting`
`343`	`331`	`// to half close the connection which is currently unsupported.`
`344`	`332`	`_shutdownReason = shutdownReason ?? new ConnectionAbortedException("The Socket transport's send loop completed gracefully.");`
`345`		`-`
`346`		`- if (_trace.IsEnabled(LogLevel.Debug))`
`347`		`- {`
`348`		`- _trace.ConnectionWriteFin(ConnectionId, _shutdownReason.Message);`
`349`		`- }`
	`333`	`+ _trace.ConnectionWriteFin(this, _shutdownReason.Message);`
`350`	`334`
`351`	`335`	`try`
`352`	`336`	`{`