KcpPeer: explicit logging with identifier for easier debugging

mischa · mischa · commit 9215db30fccc · 2023-10-28T15:15:43.000+02:00
diff --git a/kcp2k/kcp2k.Tests/KcpPeerTests.cs b/kcp2k/kcp2k.Tests/KcpPeerTests.cs
@@ -11,6 +11,7 @@ public MockPeer(KcpConfig config) : base(
             () => {},
             (_, _) => {},
             config,
+            "KcpMockPeer",
             0) {}
     }
 
diff --git a/kcp2k/kcp2k/highlevel/KcpClient.cs b/kcp2k/kcp2k/highlevel/KcpClient.cs
@@ -83,7 +83,7 @@ public void Connect(string address, ushort port)
 
             // create fresh peer for each new session
             // client doesn't need secure cookie.
-            peer = new KcpPeer(RawSend, OnAuthenticatedWrap, OnData, OnDisconnectedWrap, OnError, config, 0);
+            peer = new KcpPeer(RawSend, OnAuthenticatedWrap, OnData, OnDisconnectedWrap, OnError, config, "KcpClientPeer", 0);
 
             // some callbacks need to wrapped with some extra logic
             void OnAuthenticatedWrap()
diff --git a/kcp2k/kcp2k/highlevel/KcpPeer.cs b/kcp2k/kcp2k/highlevel/KcpPeer.cs
@@ -12,6 +12,11 @@ enum KcpState { Connected, Authenticated, Disconnected }
 
     public class KcpPeer
     {
+        // identifier for logging.
+        // we don't just want to show "KcpPeer" on server and client.
+        // name it "KcpClient/ServerPeer".
+        readonly string identifier;
+
         // kcp reliability algorithm
         internal Kcp kcp;
 
@@ -171,8 +176,12 @@ public KcpPeer(
             Action OnDisconnected,
             Action<ErrorCode, string> OnError,
             KcpConfig config,
+            String identifier,
             uint cookie)
         {
+            // initialize logging identifier
+            this.identifier = identifier;
+
             // initialize callbacks first to ensure they can be used safely.
             this.OnAuthenticated = OnAuthenticated;
             this.OnData = OnData;
@@ -225,7 +234,7 @@ void HandleTimeout(uint time)
             {
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.Timeout, $"KcpPeer: Connection timed out after not receiving any message for {timeout}ms. Disconnecting.");
+                OnError(ErrorCode.Timeout, $"{identifier}: Connection timed out after not receiving any message for {timeout}ms. Disconnecting.");
                 Disconnect();
             }
         }
@@ -237,7 +246,7 @@ void HandleDeadLink()
             {
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.Timeout, $"KcpPeer: dead_link detected: a message was retransmitted {kcp.dead_link} times without ack. Disconnecting.");
+                OnError(ErrorCode.Timeout, $"{identifier}: dead_link detected: a message was retransmitted {kcp.dead_link} times without ack. Disconnecting.");
                 Disconnect();
             }
         }
@@ -267,7 +276,7 @@ void HandleChoked()
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
                 OnError(ErrorCode.Congestion,
-                        $"KcpPeer: disconnecting connection because it can't process data fast enough.\n" +
+                        $"{identifier}: disconnecting connection because it can't process data fast enough.\n" +
                         $"Queue total {total}>{QueueDisconnectThreshold}. rcv_queue={kcp.rcv_queue.Count} snd_queue={kcp.snd_queue.Count} rcv_buf={kcp.rcv_buf.Count} snd_buf={kcp.snd_buf.Count}\n" +
                         $"* Try to Enable NoDelay, decrease INTERVAL, disable Congestion Window (= enable NOCWND!), increase SEND/RECV WINDOW or compress data.\n" +
                         $"* Or perhaps the network is simply too slow on our end, or on the other end.");
@@ -299,7 +308,7 @@ bool ReceiveNextReliable(out KcpHeader header, out ArraySegment<byte> message)
                 // we don't allow sending messages > Max, so this must be an
                 // attacker. let's disconnect to avoid allocation attacks etc.
                 // pass error to user callback. no need to log it manually.
-                OnError(ErrorCode.InvalidReceive, $"KcpPeer: possible allocation attack for msgSize {msgSize} > buffer {kcpMessageBuffer.Length}. Disconnecting the connection.");
+                OnError(ErrorCode.InvalidReceive, $"{identifier}: possible allocation attack for msgSize {msgSize} > buffer {kcpMessageBuffer.Length}. Disconnecting the connection.");
                 Disconnect();
                 return false;
             }
@@ -311,7 +320,7 @@ bool ReceiveNextReliable(out KcpHeader header, out ArraySegment<byte> message)
                 // if receive failed, close everything
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.InvalidReceive, $"KcpPeer: Receive failed with error={received}. closing connection.");
+                OnError(ErrorCode.InvalidReceive, $"{identifier}: Receive failed with error={received}. closing connection.");
                 Disconnect();
                 return false;
             }
@@ -346,7 +355,7 @@ void TickIncoming_Connected(uint time)
                         if (message.Count != 4)
                         {
                             // pass error to user callback. no need to log it manually.
-                            OnError(ErrorCode.InvalidReceive, $"KcpPeer: received invalid handshake message with size {message.Count} != 4. Disconnecting the connection.");
+                            OnError(ErrorCode.InvalidReceive, $"{identifier}: received invalid handshake message with size {message.Count} != 4. Disconnecting the connection.");
                             Disconnect();
                             return;
                         }
@@ -356,7 +365,7 @@ void TickIncoming_Connected(uint time)
                         Buffer.BlockCopy(message.Array, message.Offset, receivedCookie, 0, 4);
                         uint prettyCookie = BitConverter.ToUInt32(message.Array, message.Offset);
 
-                        Log.Info($"KcpPeer: received handshake with cookie={prettyCookie}");
+                        Log.Info($"{identifier}: received handshake with cookie={prettyCookie}");
                         state = KcpState.Authenticated;
                         OnAuthenticated?.Invoke();
                         break;
@@ -372,7 +381,7 @@ void TickIncoming_Connected(uint time)
                         // everything else is not allowed during handshake!
                         // pass error to user callback. no need to log it manually.
                         // GetType() shows Server/ClientConn instead of just Connection.
-                        OnError(ErrorCode.InvalidReceive, $"KcpPeer: received invalid header {header} while Connected. Disconnecting the connection.");
+                        OnError(ErrorCode.InvalidReceive, $"{identifier}: received invalid header {header} while Connected. Disconnecting the connection.");
                         Disconnect();
                         break;
                     }
@@ -398,7 +407,7 @@ void TickIncoming_Authenticated(uint time)
                     {
                         // should never receive another handshake after auth
                         // GetType() shows Server/ClientConn instead of just Connection.
-                        Log.Warning($"KcpPeer: received invalid header {header} while Authenticated. Disconnecting the connection.");
+                        Log.Warning($"{identifier}: received invalid header {header} while Authenticated. Disconnecting the connection.");
                         Disconnect();
                         break;
                     }
@@ -415,7 +424,7 @@ void TickIncoming_Authenticated(uint time)
                         {
                             // pass error to user callback. no need to log it manually.
                             // GetType() shows Server/ClientConn instead of just Connection.
-                            OnError(ErrorCode.InvalidReceive, $"KcpPeer: received empty Data message while Authenticated. Disconnecting the connection.");
+                            OnError(ErrorCode.InvalidReceive, $"{identifier}: received empty Data message while Authenticated. Disconnecting the connection.");
                             Disconnect();
                         }
                         break;
@@ -429,7 +438,7 @@ void TickIncoming_Authenticated(uint time)
                     {
                         // disconnect might happen
                         // GetType() shows Server/ClientConn instead of just Connection.
-                        Log.Info($"KcpPeer: received disconnect message");
+                        Log.Info($"{identifier}: received disconnect message");
                         Disconnect();
                         break;
                     }
@@ -468,23 +477,23 @@ public void TickIncoming()
                 // this is ok, the connection was closed
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.ConnectionClosed, $"KcpPeer: Disconnecting because {exception}. This is fine.");
+                OnError(ErrorCode.ConnectionClosed, $"{identifier}: Disconnecting because {exception}. This is fine.");
                 Disconnect();
             }
             catch (ObjectDisposedException exception)
             {
                 // fine, socket was closed
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.ConnectionClosed, $"KcpPeer: Disconnecting because {exception}. This is fine.");
+                OnError(ErrorCode.ConnectionClosed, $"{identifier}: Disconnecting because {exception}. This is fine.");
                 Disconnect();
             }
             catch (Exception exception)
             {
                 // unexpected
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.Unexpected, $"KcpPeer: unexpected Exception: {exception}");
+                OnError(ErrorCode.Unexpected, $"{identifier}: unexpected Exception: {exception}");
                 Disconnect();
             }
         }
@@ -517,23 +526,23 @@ public void TickOutgoing()
                 // this is ok, the connection was closed
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.ConnectionClosed, $"KcpPeer: Disconnecting because {exception}. This is fine.");
+                OnError(ErrorCode.ConnectionClosed, $"{identifier}: Disconnecting because {exception}. This is fine.");
                 Disconnect();
             }
             catch (ObjectDisposedException exception)
             {
                 // fine, socket was closed
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.ConnectionClosed, $"KcpPeer: Disconnecting because {exception}. This is fine.");
+                OnError(ErrorCode.ConnectionClosed, $"{identifier}: Disconnecting because {exception}. This is fine.");
                 Disconnect();
             }
             catch (Exception exception)
             {
                 // unexpected
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.Unexpected, $"KcpPeer: unexpected exception: {exception}");
+                OnError(ErrorCode.Unexpected, $"{identifier}: unexpected exception: {exception}");
                 Disconnect();
             }
         }
@@ -545,7 +554,7 @@ void OnRawInputReliable(ArraySegment<byte> message)
             if (input != 0)
             {
                 // GetType() shows Server/ClientConn instead of just Connection.
-                Log.Warning($"KcpPeer: Input failed with error={input} for buffer with length={message.Count - 1}");
+                Log.Warning($"{identifier}: Input failed with error={input} for buffer with length={message.Count - 1}");
             }
         }
 
@@ -596,7 +605,7 @@ void OnRawInputUnreliable(ArraySegment<byte> message)
                 //   add another 'round trip time' of latency to the handshake.
                 //
                 // it's best to simply ignore invalid unreliable messages here.
-                // Log.Info($"KcpPeer: received unreliable message while not authenticated.");
+                // Log.Info($"{identifier}: received unreliable message while not authenticated.");
             }
         }
 
@@ -621,7 +630,7 @@ public void RawInput(ArraySegment<byte> segment)
             // simply drop the message if the cookie doesn't match.
             if (state == KcpState.Authenticated && messageCookie != cookie)
             {
-                Log.Warning($"KcpPeer: dropped message with invalid cookie: {messageCookie} expected: {cookie}.");
+                Log.Warning($"{identifier}: dropped message with invalid cookie: {messageCookie} expected: {cookie}.");
                 return;
             }
 
@@ -645,7 +654,7 @@ public void RawInput(ArraySegment<byte> segment)
                     // invalid channel indicates random internet noise.
                     // servers may receive random UDP data.
                     // just ignore it, but log for easier debugging.
-                    Log.Warning($"KcpPeer: invalid channel header: {channel}, likely internet noise");
+                    Log.Warning($"{identifier}: invalid channel header: {channel}, likely internet noise");
                     break;
                 }
             }
@@ -678,7 +687,7 @@ void SendReliable(KcpHeader header, ArraySegment<byte> content)
             {
                 // otherwise content is larger than MaxMessageSize. let user know!
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.InvalidSend, $"KcpPeer: Failed to send reliable message of size {content.Count} because it's larger than ReliableMaxMessageSize={reliableMax}");
+                OnError(ErrorCode.InvalidSend, $"{identifier}: Failed to send reliable message of size {content.Count} because it's larger than ReliableMaxMessageSize={reliableMax}");
                 return;
             }
 
@@ -694,7 +703,7 @@ void SendReliable(KcpHeader header, ArraySegment<byte> content)
             if (sent < 0)
             {
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.InvalidSend, $"KcpPeer: Send failed with error={sent} for content with length={content.Count}");
+                OnError(ErrorCode.InvalidSend, $"{identifier}: Send failed with error={sent} for content with length={content.Count}");
             }
         }
 
@@ -705,7 +714,7 @@ void SendUnreliable(ArraySegment<byte> message)
             {
                 // otherwise content is larger than MaxMessageSize. let user know!
                 // GetType() shows Server/ClientConn instead of just Connection.
-                Log.Error($"KcpPeer: Failed to send unreliable message of size {message.Count} because it's larger than UnreliableMaxMessageSize={unreliableMax}");
+                Log.Error($"{identifier}: Failed to send unreliable message of size {message.Count} because it's larger than UnreliableMaxMessageSize={unreliableMax}");
                 return;
             }
 
@@ -744,7 +753,7 @@ public void SendHandshake()
             byte[] cookieBytes = BitConverter.GetBytes(cookie);
 
             // GetType() shows Server/ClientConn instead of just Connection.
-            Log.Info($"KcpPeer: sending Handshake to other end with cookie={cookie}!");
+            Log.Info($"{identifier}: sending Handshake to other end with cookie={cookie}!");
             SendReliable(KcpHeader.Handshake, new ArraySegment<byte>(cookieBytes));
         }
 
@@ -758,7 +767,7 @@ public void SendData(ArraySegment<byte> data, KcpChannel channel)
             {
                 // pass error to user callback. no need to log it manually.
                 // GetType() shows Server/ClientConn instead of just Connection.
-                OnError(ErrorCode.InvalidSend, $"KcpPeer: tried sending empty message. This should never happen. Disconnecting.");
+                OnError(ErrorCode.InvalidSend, $"{identifier}: tried sending empty message. This should never happen. Disconnecting.");
                 Disconnect();
                 return;
             }
@@ -811,7 +820,7 @@ public void Disconnect()
 
             // set as Disconnected, call event
             // GetType() shows Server/ClientConn instead of just Connection.
-            Log.Info($"KcpPeer: Disconnected.");
+            Log.Info($"{identifier}: Disconnected.");
             state = KcpState.Disconnected;
             OnDisconnected?.Invoke();
         }
diff --git a/kcp2k/kcp2k/highlevel/KcpServer.cs b/kcp2k/kcp2k/highlevel/KcpServer.cs
@@ -213,7 +213,7 @@ protected virtual KcpServerConnection CreateConnection(int connectionId)
             uint cookie = Common.GenerateCookie();
 
             // set up peer with callbacks
-            KcpPeer peer = new KcpPeer(RawSendWrap, OnAuthenticatedWrap, OnDataWrap, OnDisconnectedWrap, OnErrorWrap, config, cookie);
+            KcpPeer peer = new KcpPeer(RawSendWrap, OnAuthenticatedWrap, OnDataWrap, OnDisconnectedWrap, OnErrorWrap, config, "KcpServerPeer", cookie);
 
             // assign peer to connection
             connection.peer = peer;

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ public MockPeer(KcpConfig config) : base(`
`11`	`11`	`() => {},`
`12`	`12`	`(_, _) => {},`
`13`	`13`	`config,`
	`14`	`+ "KcpMockPeer",`
`14`	`15`	`0) {}`
`15`	`16`	`}`
`16`	`17`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,11 @@ enum KcpState { Connected, Authenticated, Disconnected }`
`12`	`12`
`13`	`13`	`public class KcpPeer`
`14`	`14`	`{`
	`15`	`+ // identifier for logging.`
	`16`	`+ // we don't just want to show "KcpPeer" on server and client.`
	`17`	`+ // name it "KcpClient/ServerPeer".`
	`18`	`+ readonly string identifier;`
	`19`	`+`
`15`	`20`	`// kcp reliability algorithm`
`16`	`21`	`internal Kcp kcp;`
`17`	`22`
`@@ -171,8 +176,12 @@ public KcpPeer(`
`171`	`176`	`Action OnDisconnected,`
`172`	`177`	`Action<ErrorCode, string> OnError,`
`173`	`178`	`KcpConfig config,`
	`179`	`+ String identifier,`
`174`	`180`	`uint cookie)`
`175`	`181`	`{`
	`182`	`+ // initialize logging identifier`
	`183`	`+ this.identifier = identifier;`
	`184`	`+`
`176`	`185`	`// initialize callbacks first to ensure they can be used safely.`
`177`	`186`	`this.OnAuthenticated = OnAuthenticated;`
`178`	`187`	`this.OnData = OnData;`
`@@ -225,7 +234,7 @@ void HandleTimeout(uint time)`
`225`	`234`	`{`
`226`	`235`	`// pass error to user callback. no need to log it manually.`
`227`	`236`	`// GetType() shows Server/ClientConn instead of just Connection.`
`228`		`- OnError(ErrorCode.Timeout, $"KcpPeer: Connection timed out after not receiving any message for {timeout}ms. Disconnecting.");`
	`237`	`+ OnError(ErrorCode.Timeout, $"{identifier}: Connection timed out after not receiving any message for {timeout}ms. Disconnecting.");`
`229`	`238`	`Disconnect();`
`230`	`239`	`}`
`231`	`240`	`}`
`@@ -237,7 +246,7 @@ void HandleDeadLink()`
`237`	`246`	`{`
`238`	`247`	`// pass error to user callback. no need to log it manually.`
`239`	`248`	`// GetType() shows Server/ClientConn instead of just Connection.`
`240`		`- OnError(ErrorCode.Timeout, $"KcpPeer: dead_link detected: a message was retransmitted {kcp.dead_link} times without ack. Disconnecting.");`
	`249`	`+ OnError(ErrorCode.Timeout, $"{identifier}: dead_link detected: a message was retransmitted {kcp.dead_link} times without ack. Disconnecting.");`
`241`	`250`	`Disconnect();`
`242`	`251`	`}`
`243`	`252`	`}`
`@@ -267,7 +276,7 @@ void HandleChoked()`
`267`	`276`	`// pass error to user callback. no need to log it manually.`
`268`	`277`	`// GetType() shows Server/ClientConn instead of just Connection.`
`269`	`278`	`OnError(ErrorCode.Congestion,`
`270`		`- $"KcpPeer: disconnecting connection because it can't process data fast enough.\n" +`
	`279`	`+ $"{identifier}: disconnecting connection because it can't process data fast enough.\n" +`
`271`	`280`	`$"Queue total {total}>{QueueDisconnectThreshold}. rcv_queue={kcp.rcv_queue.Count} snd_queue={kcp.snd_queue.Count} rcv_buf={kcp.rcv_buf.Count} snd_buf={kcp.snd_buf.Count}\n" +`
`272`	`281`	`$"* Try to Enable NoDelay, decrease INTERVAL, disable Congestion Window (= enable NOCWND!), increase SEND/RECV WINDOW or compress data.\n" +`
`273`	`282`	`$"* Or perhaps the network is simply too slow on our end, or on the other end.");`
`@@ -299,7 +308,7 @@ bool ReceiveNextReliable(out KcpHeader header, out ArraySegment<byte> message)`
`299`	`308`	`// we don't allow sending messages > Max, so this must be an`
`300`	`309`	`// attacker. let's disconnect to avoid allocation attacks etc.`
`301`	`310`	`// pass error to user callback. no need to log it manually.`
`302`		`- OnError(ErrorCode.InvalidReceive, $"KcpPeer: possible allocation attack for msgSize {msgSize} > buffer {kcpMessageBuffer.Length}. Disconnecting the connection.");`
	`311`	`+ OnError(ErrorCode.InvalidReceive, $"{identifier}: possible allocation attack for msgSize {msgSize} > buffer {kcpMessageBuffer.Length}. Disconnecting the connection.");`
`303`	`312`	`Disconnect();`
`304`	`313`	`return false;`
`305`	`314`	`}`
`@@ -311,7 +320,7 @@ bool ReceiveNextReliable(out KcpHeader header, out ArraySegment<byte> message)`
`311`	`320`	`// if receive failed, close everything`
`312`	`321`	`// pass error to user callback. no need to log it manually.`
`313`	`322`	`// GetType() shows Server/ClientConn instead of just Connection.`
`314`		`- OnError(ErrorCode.InvalidReceive, $"KcpPeer: Receive failed with error={received}. closing connection.");`
	`323`	`+ OnError(ErrorCode.InvalidReceive, $"{identifier}: Receive failed with error={received}. closing connection.");`
`315`	`324`	`Disconnect();`
`316`	`325`	`return false;`
`317`	`326`	`}`
`@@ -346,7 +355,7 @@ void TickIncoming_Connected(uint time)`
`346`	`355`	`if (message.Count != 4)`
`347`	`356`	`{`
`348`	`357`	`// pass error to user callback. no need to log it manually.`
`349`		`- OnError(ErrorCode.InvalidReceive, $"KcpPeer: received invalid handshake message with size {message.Count} != 4. Disconnecting the connection.");`
	`358`	`+ OnError(ErrorCode.InvalidReceive, $"{identifier}: received invalid handshake message with size {message.Count} != 4. Disconnecting the connection.");`
`350`	`359`	`Disconnect();`
`351`	`360`	`return;`
`352`	`361`	`}`
`@@ -356,7 +365,7 @@ void TickIncoming_Connected(uint time)`
`356`	`365`	`Buffer.BlockCopy(message.Array, message.Offset, receivedCookie, 0, 4);`
`357`	`366`	`uint prettyCookie = BitConverter.ToUInt32(message.Array, message.Offset);`
`358`	`367`
`359`		`- Log.Info($"KcpPeer: received handshake with cookie={prettyCookie}");`
	`368`	`+ Log.Info($"{identifier}: received handshake with cookie={prettyCookie}");`
`360`	`369`	`state = KcpState.Authenticated;`
`361`	`370`	`OnAuthenticated?.Invoke();`
`362`	`371`	`break;`
`@@ -372,7 +381,7 @@ void TickIncoming_Connected(uint time)`
`372`	`381`	`// everything else is not allowed during handshake!`
`373`	`382`	`// pass error to user callback. no need to log it manually.`
`374`	`383`	`// GetType() shows Server/ClientConn instead of just Connection.`
`375`		`- OnError(ErrorCode.InvalidReceive, $"KcpPeer: received invalid header {header} while Connected. Disconnecting the connection.");`
	`384`	`+ OnError(ErrorCode.InvalidReceive, $"{identifier}: received invalid header {header} while Connected. Disconnecting the connection.");`
`376`	`385`	`Disconnect();`
`377`	`386`	`break;`
`378`	`387`	`}`
`@@ -398,7 +407,7 @@ void TickIncoming_Authenticated(uint time)`
`398`	`407`	`{`
`399`	`408`	`// should never receive another handshake after auth`
`400`	`409`	`// GetType() shows Server/ClientConn instead of just Connection.`
`401`		`- Log.Warning($"KcpPeer: received invalid header {header} while Authenticated. Disconnecting the connection.");`
	`410`	`+ Log.Warning($"{identifier}: received invalid header {header} while Authenticated. Disconnecting the connection.");`
`402`	`411`	`Disconnect();`
`403`	`412`	`break;`
`404`	`413`	`}`
`@@ -415,7 +424,7 @@ void TickIncoming_Authenticated(uint time)`
`415`	`424`	`{`
`416`	`425`	`// pass error to user callback. no need to log it manually.`
`417`	`426`	`// GetType() shows Server/ClientConn instead of just Connection.`
`418`		`- OnError(ErrorCode.InvalidReceive, $"KcpPeer: received empty Data message while Authenticated. Disconnecting the connection.");`
	`427`	`+ OnError(ErrorCode.InvalidReceive, $"{identifier}: received empty Data message while Authenticated. Disconnecting the connection.");`
`419`	`428`	`Disconnect();`
`420`	`429`	`}`
`421`	`430`	`break;`
`@@ -429,7 +438,7 @@ void TickIncoming_Authenticated(uint time)`
`429`	`438`	`{`
`430`	`439`	`// disconnect might happen`
`431`	`440`	`// GetType() shows Server/ClientConn instead of just Connection.`
`432`		`- Log.Info($"KcpPeer: received disconnect message");`
	`441`	`+ Log.Info($"{identifier}: received disconnect message");`
`433`	`442`	`Disconnect();`
`434`	`443`	`break;`
`435`	`444`	`}`
`@@ -468,23 +477,23 @@ public void TickIncoming()`
`468`	`477`	`// this is ok, the connection was closed`
`469`	`478`	`// pass error to user callback. no need to log it manually.`
`470`	`479`	`// GetType() shows Server/ClientConn instead of just Connection.`
`471`		`- OnError(ErrorCode.ConnectionClosed, $"KcpPeer: Disconnecting because {exception}. This is fine.");`
	`480`	`+ OnError(ErrorCode.ConnectionClosed, $"{identifier}: Disconnecting because {exception}. This is fine.");`
`472`	`481`	`Disconnect();`
`473`	`482`	`}`
`474`	`483`	`catch (ObjectDisposedException exception)`
`475`	`484`	`{`
`476`	`485`	`// fine, socket was closed`
`477`	`486`	`// pass error to user callback. no need to log it manually.`
`478`	`487`	`// GetType() shows Server/ClientConn instead of just Connection.`
`479`		`- OnError(ErrorCode.ConnectionClosed, $"KcpPeer: Disconnecting because {exception}. This is fine.");`
	`488`	`+ OnError(ErrorCode.ConnectionClosed, $"{identifier}: Disconnecting because {exception}. This is fine.");`
`480`	`489`	`Disconnect();`
`481`	`490`	`}`
`482`	`491`	`catch (Exception exception)`
`483`	`492`	`{`
`484`	`493`	`// unexpected`
`485`	`494`	`// pass error to user callback. no need to log it manually.`
`486`	`495`	`// GetType() shows Server/ClientConn instead of just Connection.`
`487`		`- OnError(ErrorCode.Unexpected, $"KcpPeer: unexpected Exception: {exception}");`
	`496`	`+ OnError(ErrorCode.Unexpected, $"{identifier}: unexpected Exception: {exception}");`
`488`	`497`	`Disconnect();`
`489`	`498`	`}`
`490`	`499`	`}`
`@@ -517,23 +526,23 @@ public void TickOutgoing()`
`517`	`526`	`// this is ok, the connection was closed`
`518`	`527`	`// pass error to user callback. no need to log it manually.`
`519`	`528`	`// GetType() shows Server/ClientConn instead of just Connection.`
`520`		`- OnError(ErrorCode.ConnectionClosed, $"KcpPeer: Disconnecting because {exception}. This is fine.");`
	`529`	`+ OnError(ErrorCode.ConnectionClosed, $"{identifier}: Disconnecting because {exception}. This is fine.");`
`521`	`530`	`Disconnect();`
`522`	`531`	`}`
`523`	`532`	`catch (ObjectDisposedException exception)`
`524`	`533`	`{`
`525`	`534`	`// fine, socket was closed`
`526`	`535`	`// pass error to user callback. no need to log it manually.`
`527`	`536`	`// GetType() shows Server/ClientConn instead of just Connection.`
`528`		`- OnError(ErrorCode.ConnectionClosed, $"KcpPeer: Disconnecting because {exception}. This is fine.");`
	`537`	`+ OnError(ErrorCode.ConnectionClosed, $"{identifier}: Disconnecting because {exception}. This is fine.");`
`529`	`538`	`Disconnect();`
`530`	`539`	`}`
`531`	`540`	`catch (Exception exception)`
`532`	`541`	`{`
`533`	`542`	`// unexpected`
`534`	`543`	`// pass error to user callback. no need to log it manually.`
`535`	`544`	`// GetType() shows Server/ClientConn instead of just Connection.`
`536`		`- OnError(ErrorCode.Unexpected, $"KcpPeer: unexpected exception: {exception}");`
	`545`	`+ OnError(ErrorCode.Unexpected, $"{identifier}: unexpected exception: {exception}");`
`537`	`546`	`Disconnect();`
`538`	`547`	`}`
`539`	`548`	`}`
`@@ -545,7 +554,7 @@ void OnRawInputReliable(ArraySegment<byte> message)`
`545`	`554`	`if (input != 0)`
`546`	`555`	`{`
`547`	`556`	`// GetType() shows Server/ClientConn instead of just Connection.`
`548`		`- Log.Warning($"KcpPeer: Input failed with error={input} for buffer with length={message.Count - 1}");`
	`557`	`+ Log.Warning($"{identifier}: Input failed with error={input} for buffer with length={message.Count - 1}");`
`549`	`558`	`}`
`550`	`559`	`}`
`551`	`560`
`@@ -596,7 +605,7 @@ void OnRawInputUnreliable(ArraySegment<byte> message)`
`596`	`605`	`// add another 'round trip time' of latency to the handshake.`
`597`	`606`	`//`
`598`	`607`	`// it's best to simply ignore invalid unreliable messages here.`
`599`		`- // Log.Info($"KcpPeer: received unreliable message while not authenticated.");`
	`608`	`+ // Log.Info($"{identifier}: received unreliable message while not authenticated.");`
`600`	`609`	`}`
`601`	`610`	`}`
`602`	`611`
`@@ -621,7 +630,7 @@ public void RawInput(ArraySegment<byte> segment)`
`621`	`630`	`// simply drop the message if the cookie doesn't match.`
`622`	`631`	`if (state == KcpState.Authenticated && messageCookie != cookie)`
`623`	`632`	`{`
`624`		`- Log.Warning($"KcpPeer: dropped message with invalid cookie: {messageCookie} expected: {cookie}.");`
	`633`	`+ Log.Warning($"{identifier}: dropped message with invalid cookie: {messageCookie} expected: {cookie}.");`
`625`	`634`	`return;`
`626`	`635`	`}`
`627`	`636`
`@@ -645,7 +654,7 @@ public void RawInput(ArraySegment<byte> segment)`
`645`	`654`	`// invalid channel indicates random internet noise.`
`646`	`655`	`// servers may receive random UDP data.`
`647`	`656`	`// just ignore it, but log for easier debugging.`
`648`		`- Log.Warning($"KcpPeer: invalid channel header: {channel}, likely internet noise");`
	`657`	`+ Log.Warning($"{identifier}: invalid channel header: {channel}, likely internet noise");`
`649`	`658`	`break;`
`650`	`659`	`}`
`651`	`660`	`}`
`@@ -678,7 +687,7 @@ void SendReliable(KcpHeader header, ArraySegment<byte> content)`
`678`	`687`	`{`
`679`	`688`	`// otherwise content is larger than MaxMessageSize. let user know!`
`680`	`689`	`// GetType() shows Server/ClientConn instead of just Connection.`
`681`		`- OnError(ErrorCode.InvalidSend, $"KcpPeer: Failed to send reliable message of size {content.Count} because it's larger than ReliableMaxMessageSize={reliableMax}");`
	`690`	`+ OnError(ErrorCode.InvalidSend, $"{identifier}: Failed to send reliable message of size {content.Count} because it's larger than ReliableMaxMessageSize={reliableMax}");`
`682`	`691`	`return;`
`683`	`692`	`}`
`684`	`693`
`@@ -694,7 +703,7 @@ void SendReliable(KcpHeader header, ArraySegment<byte> content)`
`694`	`703`	`if (sent < 0)`
`695`	`704`	`{`
`696`	`705`	`// GetType() shows Server/ClientConn instead of just Connection.`
`697`		`- OnError(ErrorCode.InvalidSend, $"KcpPeer: Send failed with error={sent} for content with length={content.Count}");`
	`706`	`+ OnError(ErrorCode.InvalidSend, $"{identifier}: Send failed with error={sent} for content with length={content.Count}");`
`698`	`707`	`}`
`699`	`708`	`}`
`700`	`709`
`@@ -705,7 +714,7 @@ void SendUnreliable(ArraySegment<byte> message)`
`705`	`714`	`{`
`706`	`715`	`// otherwise content is larger than MaxMessageSize. let user know!`
`707`	`716`	`// GetType() shows Server/ClientConn instead of just Connection.`
`708`		`- Log.Error($"KcpPeer: Failed to send unreliable message of size {message.Count} because it's larger than UnreliableMaxMessageSize={unreliableMax}");`
	`717`	`+ Log.Error($"{identifier}: Failed to send unreliable message of size {message.Count} because it's larger than UnreliableMaxMessageSize={unreliableMax}");`
`709`	`718`	`return;`
`710`	`719`	`}`
`711`	`720`
`@@ -744,7 +753,7 @@ public void SendHandshake()`
`744`	`753`	`byte[] cookieBytes = BitConverter.GetBytes(cookie);`
`745`	`754`
`746`	`755`	`// GetType() shows Server/ClientConn instead of just Connection.`
`747`		`- Log.Info($"KcpPeer: sending Handshake to other end with cookie={cookie}!");`
	`756`	`+ Log.Info($"{identifier}: sending Handshake to other end with cookie={cookie}!");`
`748`	`757`	`SendReliable(KcpHeader.Handshake, new ArraySegment<byte>(cookieBytes));`
`749`	`758`	`}`
`750`	`759`
`@@ -758,7 +767,7 @@ public void SendData(ArraySegment<byte> data, KcpChannel channel)`
`758`	`767`	`{`
`759`	`768`	`// pass error to user callback. no need to log it manually.`
`760`	`769`	`// GetType() shows Server/ClientConn instead of just Connection.`
`761`		`- OnError(ErrorCode.InvalidSend, $"KcpPeer: tried sending empty message. This should never happen. Disconnecting.");`
	`770`	`+ OnError(ErrorCode.InvalidSend, $"{identifier}: tried sending empty message. This should never happen. Disconnecting.");`
`762`	`771`	`Disconnect();`
`763`	`772`	`return;`
`764`	`773`	`}`
`@@ -811,7 +820,7 @@ public void Disconnect()`
`811`	`820`
`812`	`821`	`// set as Disconnected, call event`
`813`	`822`	`// GetType() shows Server/ClientConn instead of just Connection.`
`814`		`- Log.Info($"KcpPeer: Disconnected.");`
	`823`	`+ Log.Info($"{identifier}: Disconnected.");`
`815`	`824`	`state = KcpState.Disconnected;`
`816`	`825`	`OnDisconnected?.Invoke();`
`817`	`826`	`}`