update

This update is a work in progress resolution to the issue where disconnect event notifications were too vague and did not provide any way to know what the cause of the disconnect was.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs

@@ -373,10 +373,14 @@ private ulong GetServerTransportId()
         {
             if (NetworkManager != null)
             {
-                var transport = NetworkManager.NetworkConfig.NetworkTransport;
-                if (transport != null)
+                if (Transport == null && NetworkManager.NetworkConfig.NetworkTransport != null)
+                {
+                    Transport = NetworkManager.NetworkConfig.NetworkTransport;
+                }
+
+                if (Transport)
                 {
-                    return transport.ServerClientId;
+                    return Transport.ServerClientId;
                 }
 
                 throw new NullReferenceException($"The transport in the active {nameof(NetworkConfig)} is null");
@@ -412,7 +416,7 @@ internal void PollAndHandleNetworkEvents()
             NetworkEvent networkEvent;
             do
             {
-                networkEvent = NetworkManager.NetworkConfig.NetworkTransport.PollEvent(out ulong transportClientId, out ArraySegment<byte> payload, out float receiveTime);
+                networkEvent = Transport.PollEvent(out ulong transportClientId, out ArraySegment<byte> payload, out float receiveTime);
                 HandleNetworkEvent(networkEvent, transportClientId, payload, receiveTime);
                 if (networkEvent == NetworkEvent.Disconnect || networkEvent == NetworkEvent.TransportFailure)
                 {
@@ -520,6 +524,22 @@ internal void DataEventHandler(ulong transportClientId, ref ArraySegment<byte> p
 #endif
         }
 
+        private void GenerateDisconnectInformation(ulong clientId, ulong transportClientId, string reason = null)
+        {
+            var header = $"[Disconnect Event][Client-{clientId}]";
+            var existingDisconnectReason = DisconnectReason;
+            var defaultMessage = reason ?? $"Disconnected.";
+            // Just go ahead and set this whether client or server so any subscriptions to a disconnect event can check the DisconnectReason
+            // to determine why the client disconnected
+            DisconnectReason = Transport.DisconnectEvent == NetworkTransport.DisconnectEvents.Disconnected ? $"{header} {defaultMessage}" :
+                $"{header}[{Transport.DisconnectEvent}] {defaultMessage}";
+            DisconnectReason = $"{DisconnectReason}\n{existingDisconnectReason}";
+            if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+            {
+                NetworkLog.LogInfo($"{DisconnectReason}");
+            }
+        }
+
         /// <summary>
         /// Handles a <see cref="NetworkEvent.Disconnect"/> event.
         /// </summary>
@@ -528,11 +548,8 @@ internal void DisconnectEventHandler(ulong transportClientId)
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_TransportDisconnect.Begin();
 #endif
-            var clientId = TransportIdCleanUp(transportClientId);
-            if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
-            {
-                NetworkLog.LogInfo($"Disconnect Event From {clientId}");
-            }
+            var clientId = TransportIdToClientId(transportClientId);
+            TransportIdCleanUp(transportClientId);
 
             // If we are a client and we have gotten the ServerClientId back, then use our assigned local id as the client that was
             // disconnected (either the user disconnected or the server disconnected, but the client that disconnected is the LocalClientId)
@@ -541,6 +558,8 @@ internal void DisconnectEventHandler(ulong transportClientId)
                 clientId = NetworkManager.LocalClientId;
             }
 
+            GenerateDisconnectInformation(clientId, transportClientId);
+
             // Process the incoming message queue so that we get everything from the server disconnecting us or, if we are the server, so we got everything from that client.
             MessageManager.ProcessIncomingMessageQueue();
 
@@ -1327,7 +1346,7 @@ internal void OnClientDisconnectFromServer(ulong clientId)
             if (ClientIdToTransportIdMap.ContainsKey(clientId))
             {
                 var transportId = ClientIdToTransportId(clientId);
-                NetworkManager.NetworkConfig.NetworkTransport.DisconnectRemoteClient(transportId);
+                Transport.DisconnectRemoteClient(transportId);
 
                 InvokeOnClientDisconnectCallback(clientId);
 
@@ -1393,10 +1412,15 @@ internal void DisconnectClient(ulong clientId, string reason = null)
                 };
                 SendMessage(ref disconnectReason, NetworkDelivery.Reliable, clientId);
             }
+            Transport.SetDisconnectEvent((byte)Networking.Transport.Error.DisconnectReason.Default);
 
+            GenerateDisconnectInformation(clientId, ClientIdToTransportId(clientId), reason);
             DisconnectRemoteClient(clientId);
         }
 
+        internal NetworkTransport Transport;
+        internal NetworkTransport.DisconnectEvents DisconnectEvent => Transport ? Transport.DisconnectEvent : NetworkTransport.DisconnectEvents.Disconnected;
+
         /// <summary>
         /// Should be invoked when starting a server-host or client
         /// </summary>
@@ -1418,10 +1442,14 @@ internal void Initialize(NetworkManager networkManager)
             NetworkManager = networkManager;
             MessageManager = networkManager.MessageManager;
 
-            NetworkManager.NetworkConfig.NetworkTransport.NetworkMetrics = NetworkManager.MetricsManager.NetworkMetrics;
-
-            NetworkManager.NetworkConfig.NetworkTransport.OnTransportEvent += HandleNetworkEvent;
-            NetworkManager.NetworkConfig.NetworkTransport.Initialize(networkManager);
+            Transport = NetworkManager.NetworkConfig.NetworkTransport;
+            if (Transport)
+            {
+                Transport.NetworkMetrics = NetworkManager.MetricsManager.NetworkMetrics;
+                Transport.OnTransportEvent += HandleNetworkEvent;
+                Transport.Initialize(networkManager);
+                Transport.CreateDisconnectEventMap();
+            }
         }
 
         /// <summary>
@@ -1435,7 +1463,7 @@ internal void Shutdown()
                 var disconnectedIds = new HashSet<ulong>();
 
                 //Don't know if I have to disconnect the clients. I'm assuming the NetworkTransport does all the cleaning on shutdown. But this way the clients get a disconnect message from server (so long it does't get lost)
-                var serverTransportId = NetworkManager.NetworkConfig.NetworkTransport.ServerClientId;
+                var serverTransportId = GetServerTransportId();
                 foreach (KeyValuePair<ulong, NetworkClient> pair in ConnectedClients)
                 {
                     if (!disconnectedIds.Contains(pair.Key))
@@ -1478,7 +1506,7 @@ internal void Shutdown()
                 // Client only, send disconnect and if transport throws and exception, log the exception and continue the shutdown sequence (or forever be shutting down)
                 try
                 {
-                    NetworkManager.NetworkConfig.NetworkTransport.DisconnectLocalClient();
+                    Transport.DisconnectLocalClient();
                 }
                 catch (Exception ex)
                 {
@@ -1508,6 +1536,11 @@ internal void Shutdown()
                 var transport = NetworkManager.NetworkConfig?.NetworkTransport;
                 if (transport != null)
                 {
+                    if (LocalClient.IsServer)
+                    {
+                        GenerateDisconnectInformation(NetworkManager.ServerClientId, Transport.ServerClientId, "Disconnecting due to shutdown.");
+                    }
+                    transport.CleanDisconnectEventMap();
                     transport.Shutdown();
 
                     if (NetworkManager.LogLevel <= LogLevel.Developer)

com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs

@@ -2,14 +2,14 @@
 using System.Collections.Generic;
 using Unity.Collections;
 using System.Linq;
+using Unity.Netcode.Components;
 using UnityEngine;
 #if UNITY_EDITOR
 using UnityEditor;
 using PackageInfo = UnityEditor.PackageManager.PackageInfo;
 #endif
 using UnityEngine.SceneManagement;
 using Debug = UnityEngine.Debug;
-using Unity.Netcode.Components;
 
 namespace Unity.Netcode
 {
@@ -611,6 +611,16 @@ public ulong LocalClientId
         /// </summary>
         public string DisconnectReason => ConnectionManager.DisconnectReason;
 
+        /// <summary>
+        /// If supported by the <see cref="NetworkTransport"/>, this <see cref="NetworkTransport.DisconnectEvents"/> property will be set for each disconnect event.
+        /// If not supported, then this remain as the default <see cref="Networking.Transport.Error.DisconnectReason"/> value.
+        /// </summary>
+        /// <remarks>
+        /// A server/host will receive notifications for remote clients disconnecting and will update this <see cref="Networking.Transport.Error.DisconnectReason"/> property
+        /// upon each disconnect event.<br />
+        /// </remarks>
+        public NetworkTransport.DisconnectEvents DisconnectEvent => ConnectionManager.DisconnectEvent;
+
         /// <summary>
         /// Is true when a server or host is listening for connections.
         /// Is true when a client is connecting or connected to a network session.
@@ -1485,7 +1495,7 @@ private void HostServerInitialize()
         /// Disconnects the remote client.
         /// </summary>
         /// <param name="clientId">The ClientId to disconnect</param>
-        public void DisconnectClient(ulong clientId) => ConnectionManager.DisconnectClient(clientId);
+        public void DisconnectClient(ulong clientId) => ConnectionManager.DisconnectClient(clientId, $"Client-{clientId} disconnected by server.");
 
         /// <summary>
         /// Disconnects the remote client.

com.unity.netcode.gameobjects/Runtime/Transports/NetworkTransport.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using UnityEngine;
 
 namespace Unity.Netcode
@@ -164,6 +165,79 @@ internal NetworkTopologyTypes CurrentTopology()
         {
             return OnCurrentTopology();
         }
+
+
+        public enum DisconnectEvents : byte
+        {
+            Disconnected,
+            ProtocolTimeout,
+            MaxConnectionAttempts,
+            ClosedByRemote,
+            ClosedRemoteConnection,
+            AuthenticationFailure,
+            ProtocolError,
+        }
+
+        public DisconnectEvents DisconnectEvent { get; private set; }
+        private Dictionary<byte, DisconnectEvents> m_DisconnectEventMap = new Dictionary<byte, DisconnectEvents>();
+
+        /// <summary>
+        /// This should be invoked by the <see cref="NetworkTransport"/> derived class when a transport level disconnect event occurs.<br />
+        /// If there is a map for the specific transport event id, then <see cref="DisconnectEvent"/> will be set to the equivalent <see cref="DisconnectEvents"/> value.
+        /// </summary>
+        /// <param name="disconnectEventId">The transport's disconnect event identifer.</param>
+        public void SetDisconnectEvent(byte disconnectEventId)
+        {
+            if (m_DisconnectEventMap.ContainsKey(disconnectEventId))
+            {
+                DisconnectEvent = m_DisconnectEventMap[disconnectEventId];
+            }
+            else // If there are no maps, then this will always report just disconnected.
+            {
+                DisconnectEvent = DisconnectEvents.Disconnected;
+            }
+        }
+
+        internal void SetDisconnectEvent(DisconnectEvents disconnectEvent)
+        {
+            DisconnectEvent = disconnectEvent;
+        }
+
+        /// <summary>
+        /// Adds a map between the <see cref="DisconnectEvents"/> value and the transports equivalent event identifier.
+        /// </summary>
+        /// <param name="disconnectEvents">The <see cref="DisconnectEvents"/> value to be mapped.</param>
+        /// <param name="targetEventId">The transport's equivalent event identifier value.</param>
+        protected void AddDisconnectEventMap(DisconnectEvents disconnectEvents, byte targetEventId)
+        {
+            if (!m_DisconnectEventMap.ContainsKey(targetEventId))
+            {
+                m_DisconnectEventMap.Add(targetEventId, disconnectEvents);
+            }
+        }
+
+        /// <summary>
+        /// Override this method to create a disconnect event mapping table that will translate the transport's equivalent for each enum in <see cref="DisconnectEvents"/>.<br />
+        /// This method is invoked during <see cref="NetworkConnectionManager.Initialize(NetworkManager)"/> just after <see cref="Initialize(NetworkManager)"/> has been invoked.
+        /// </summary>
+        /// <remarks>
+        /// You can use <see cref="AddDisconnectEventMap"/> to register a map between <see cref="DisconnectEvents"/> and the transport's disconnect event equivalent.
+        /// </remarks>
+        protected virtual void OnCreateDisconnectEventMap()
+        {
+
+        }
+
+        internal void CreateDisconnectEventMap()
+        {
+            OnCreateDisconnectEventMap();
+        }
+
+        internal void CleanDisconnectEventMap()
+        {
+            DisconnectEvent = DisconnectEvents.Disconnected;
+            m_DisconnectEventMap.Clear();
+        }
     }
 
     /// <summary>

com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs

@@ -15,9 +15,11 @@
 using Unity.Collections.LowLevel.Unsafe;
 using Unity.Jobs;
 using Unity.Networking.Transport;
+using Unity.Networking.Transport.Error;
 using Unity.Networking.Transport.Relay;
 using Unity.Networking.Transport.TLS;
 using Unity.Networking.Transport.Utilities;
+using UnityEditor.PackageManager;
 using UnityEngine;
 
 using NetcodeEvent = Unity.Netcode.NetworkEvent;
@@ -1056,6 +1058,9 @@ private bool ProcessEvent()
                             Debug.LogError("Failed to connect to server.");
                         }
 
+                        // Set the disconnect event error code
+                        SetDisconnectEvent(reader.ReadByte());
+
                         m_ServerClientId = default;
                         m_ReliableReceiveQueues.Remove(clientId);
                         ClearSendQueuesForClientId(clientId);
@@ -1348,7 +1353,7 @@ public override void DisconnectRemoteClient(ulong clientId)
             }
 #endif
 
-            if (m_Driver.IsCreated)
+            if (m_NetworkManager.IsServer && m_Driver.IsCreated)
             {
                 FlushSendQueuesForClientId(clientId);
 
@@ -1363,6 +1368,17 @@ public override void DisconnectRemoteClient(ulong clientId)
             }
         }
 
+        protected override void OnCreateDisconnectEventMap()
+        {
+            AddDisconnectEventMap(DisconnectEvents.Disconnected, (byte)DisconnectReason.Default);
+            AddDisconnectEventMap(DisconnectEvents.ProtocolTimeout, (byte)DisconnectReason.Timeout);
+            AddDisconnectEventMap(DisconnectEvents.MaxConnectionAttempts, (byte)DisconnectReason.MaxConnectionAttempts);
+            AddDisconnectEventMap(DisconnectEvents.ClosedByRemote, (byte)DisconnectReason.ClosedByRemote);
+            AddDisconnectEventMap(DisconnectEvents.AuthenticationFailure, (byte)DisconnectReason.AuthenticationFailure);            
+            AddDisconnectEventMap(DisconnectEvents.ProtocolError, (byte)DisconnectReason.ProtocolError);
+            base.OnCreateDisconnectEventMap();
+        }
+
         /// <summary>
         /// Gets the current RTT for a specific client
         /// </summary>