Adding in Performance Tick Data that can be propagated out for external consumption

kvassall-unity · kvassall-unity · commit f1e94e5bbc6f · 2021-02-22T10:56:40.000-06:00
diff --git a/com.unity.multiplayer.mlapi/Runtime/Core/NetworkedBehaviour.cs b/com.unity.multiplayer.mlapi/Runtime/Core/NetworkedBehaviour.cs
@@ -800,6 +800,7 @@ internal static void HandleNetworkedVarDeltas(List<INetworkedVar> networkedVarLi
                     long readStartPos = stream.Position;
 
                     networkedVarList[i].ReadDelta(stream, IsServer);
+                    PerformanceDataManager.Increment(ProfilerConstants.NumberNetworkVarsReceived);
                     ProfilerStatManager.networkVarsRcvd.Record();
 
                     if (NetworkingManager.Singleton.NetworkConfig.EnsureNetworkedVarLengthSafety)
@@ -867,6 +868,7 @@ internal static void HandleNetworkedVarUpdate(List<INetworkedVar> networkedVarLi
                     long readStartPos = stream.Position;
 
                     networkedVarList[i].ReadField(stream);
+                    PerformanceDataManager.Increment(ProfilerConstants.NumberNetworkVarsReceived);
                     ProfilerStatManager.networkVarsRcvd.Record();
 
                     if (NetworkingManager.Singleton.NetworkConfig.EnsureNetworkedVarLengthSafety)
diff --git a/com.unity.multiplayer.mlapi/Runtime/Core/NetworkingManager.cs b/com.unity.multiplayer.mlapi/Runtime/Core/NetworkingManager.cs
@@ -72,6 +72,10 @@ public class NetworkingManager : UpdateLoopBehaviour
 #endif
         public RpcQueueContainer rpcQueueContainer { get; private set; }
 
+        public delegate void PerformanceDataEventHandler(PerformanceTickData profilerData);
+
+        public event PerformanceDataEventHandler OnPerformanceDataEvent;
+
         /// <summary>
         /// A synchronized time, represents the time in seconds since the server application started. Is replicated across all clients
         /// </summary>
@@ -735,11 +739,14 @@ private void Awake()
         /// </summary>
         private void NetworkPreUpdate()
         {
+            PerformanceDataManager.BeginNewTick();
+
             if (IsListening)
             {
                 // Process received data
                 if ((NetworkTime - m_LastReceiveTickTime >= (1f / NetworkConfig.ReceiveTickrate)) || NetworkConfig.ReceiveTickrate <= 0)
                 {
+                    PerformanceDataManager.Increment(ProfilerConstants.ReceiveTickRate);
                     ProfilerStatManager.rcvTickRate.Record();
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
                     s_ReceiveTick.Begin();
@@ -853,6 +860,15 @@ private void NetworkUpdate()
                     currentNetworkTimeOffset += Mathf.Clamp(networkTimeOffset - currentNetworkTimeOffset, -maxDelta, maxDelta);
                 }
             }
+
+            var profileTransport = NetworkConfig.NetworkTransport as ITransportProfilerData;
+            if (profileTransport != null)
+            {
+                var transportProfilerData = profileTransport.GetTransportGetData();
+                PerformanceDataManager.AddTransportData(transportProfilerData);
+            }
+
+            OnPerformanceDataEvent?.Invoke(PerformanceDataManager.GetData());
         }
 
         internal void UpdateNetworkTime(ulong clientId, float netTime, float receiveTime, bool warp = false)
@@ -906,6 +922,7 @@ internal IEnumerator TimeOutSwitchSceneProgress(SceneSwitchProgress switchSceneP
 
         private void HandleRawTransportPoll(NetEventType eventType, ulong clientId, Channel channel, ArraySegment<byte> payload, float receiveTime)
         {
+            PerformanceDataManager.Increment(ProfilerConstants.NumberBytesReceived, payload.Count);
             ProfilerStatManager.bytesRcvd.Record(payload.Count);
             switch (eventType)
             {
@@ -1166,6 +1183,7 @@ internal void HandleIncomingData(ulong clientId, Channel channel, ArraySegment<b
                                 {
                                     m_RpcBatcher.ReceiveItems(messageStream, ReceiveCallback, RpcQueueContainer.QueueItemType.ServerRpc, clientId, receiveTime);
                                     ProfilerStatManager.rpcBatchesRcvd.Record();
+                                    PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCBatchesReceived);
                                 }
                                 else
                                 {
@@ -1188,6 +1206,7 @@ internal void HandleIncomingData(ulong clientId, Channel channel, ArraySegment<b
                                 {
                                     m_RpcBatcher.ReceiveItems(messageStream, ReceiveCallback, RpcQueueContainer.QueueItemType.ClientRpc, clientId, receiveTime);
                                     ProfilerStatManager.rpcBatchesRcvd.Record();
+                                    PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCBatchesReceived);
                                 }
                                 else
                                 {
@@ -1339,6 +1358,7 @@ public void DisconnectClient(ulong clientId)
             {
                 if (ConnectedClientsList[i].ClientId == clientId) {
                     ConnectedClientsList.RemoveAt(i);
+                    PerformanceDataManager.Increment(ProfilerConstants.NumberOfConnections, -1);
                     ProfilerStatManager.connections.Record(-1);
                 }
             }
@@ -1404,6 +1424,7 @@ internal void OnClientDisconnectFromServer(ulong clientId)
                     if (ConnectedClientsList[i].ClientId == clientId)
                     {
                         ConnectedClientsList.RemoveAt(i);
+                        PerformanceDataManager.Increment(ProfilerConstants.NumberOfConnections, -1);
                         ProfilerStatManager.connections.Record(-1);
                         break;
                     }
@@ -1452,6 +1473,7 @@ internal void HandleApproval(ulong clientId, bool createPlayerObject, ulong? pla
                 ConnectedClients.Add(clientId, client);
                 ConnectedClientsList.Add(client);
 
+                PerformanceDataManager.Increment(ProfilerConstants.NumberOfConnections);
                 ProfilerStatManager.connections.Record();
 
                 // This packet is unreliable, but if it gets through it should provide a much better sync than the potentially huge approval message.
diff --git a/com.unity.multiplayer.mlapi/Runtime/Messaging/InternalMessageHandler.cs b/com.unity.multiplayer.mlapi/Runtime/Messaging/InternalMessageHandler.cs
@@ -694,13 +694,15 @@ internal static void RPCReceiveQueueItem(ulong clientId, Stream stream, float re
             }
 
             ProfilerStatManager.rpcsRcvd.Record();
+            PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsReceived);
 
             var rpcQueueContainer = NetworkingManager.Singleton.rpcQueueContainer;
             rpcQueueContainer.AddQueueItemToInboundFrame(queueItemType, receiveTime, clientId, (BitStream)stream);
         }
 
         internal static void HandleUnnamedMessage(ulong clientId, Stream stream)
         {
+            PerformanceDataManager.Increment(ProfilerConstants.NumberOfUnnamedMessages);
             ProfilerStatManager.unnamedMessage.Record();
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_HandleUnnamedMessage.Begin();
@@ -713,6 +715,7 @@ internal static void HandleUnnamedMessage(ulong clientId, Stream stream)
 
         internal static void HandleNamedMessage(ulong clientId, Stream stream)
         {
+            PerformanceDataManager.Increment(ProfilerConstants.NumberOfNamedMessages);
             ProfilerStatManager.namedMessage.Record();
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_HandleNamedMessage.Begin();
diff --git a/com.unity.multiplayer.mlapi/Runtime/Messaging/InternalMessageSender.cs b/com.unity.multiplayer.mlapi/Runtime/Messaging/InternalMessageSender.cs
@@ -26,6 +26,7 @@ internal static void Send(ulong clientId, byte messageType, Channel channel, Bit
 
                 NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);
                 ProfilerStatManager.bytesSent.Record((int)stream.Length);
+                PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)stream.Length);
 
                 NetworkProfiler.EndEvent();
             }
@@ -57,6 +58,7 @@ internal static void Send(byte messageType, Channel channel, BitStream messageSt
 
                         NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);
                         ProfilerStatManager.bytesSent.Record((int)stream.Length);
+                        PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)stream.Length);
                     }
                     NetworkProfiler.EndEvent();
                 }
@@ -95,6 +97,7 @@ internal static void Send(byte messageType, Channel channel, List<ulong> clientI
 
                         NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientIds[i], new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);
                         ProfilerStatManager.bytesSent.Record((int)stream.Length);
+                        PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)stream.Length);
                     }
                     NetworkProfiler.EndEvent();
                 }
@@ -131,6 +134,7 @@ internal static void Send(byte messageType, Channel channel, ulong clientIdToIgn
 
                         NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);
                         ProfilerStatManager.bytesSent.Record((int)stream.Length);
+                        PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)stream.Length);
                     }
                     NetworkProfiler.EndEvent();
                 }
diff --git a/com.unity.multiplayer.mlapi/Runtime/Messaging/RpcBatcher.cs b/com.unity.multiplayer.mlapi/Runtime/Messaging/RpcBatcher.cs
@@ -149,6 +149,8 @@ public void QueueItem(in RpcFrameQueueItem queueItem)
 
                 ProfilerStatManager.bytesSent.Record(queueItem.messageData.Count);
                 ProfilerStatManager.rpcsSent.Record();
+                PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, queueItem.messageData.Count);
+                PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsSent);
             }
         }
 
@@ -178,6 +180,7 @@ public void SendItems(int thresholdBytes, SendCallbackType sendCallback)
                         entry.Value.Stream.Position = 0;
                         entry.Value.IsEmpty = true;
                         ProfilerStatManager.rpcBatchesSent.Record();
+                        PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCBatchesSent);
                     }
                 }
             }
diff --git a/com.unity.multiplayer.mlapi/Runtime/Messaging/RpcQueue/RpcQueueContainer.cs b/com.unity.multiplayer.mlapi/Runtime/Messaging/RpcQueue/RpcQueueContainer.cs
@@ -251,10 +251,12 @@ public void AdvanceFrameHistory(QueueHistoryFrame.QueueFrameType queueType)
                     if (queueType == QueueHistoryFrame.QueueFrameType.Inbound)
                     {
                         ProfilerStatManager.rpcInQueueSize.Record((int)queueHistoryItem.totalSize);
+                        PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsInQueueSize, (int)queueHistoryItem.totalSize);
                     }
                     else
                     {
                         ProfilerStatManager.rpcOutQueueSize.Record((int)queueHistoryItem.totalSize);
+                        PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsOutQueueSize, (int)queueHistoryItem.totalSize);
                     }
                 }
 
diff --git a/com.unity.multiplayer.mlapi/Runtime/Messaging/RpcQueue/RpcQueueProcessor.cs b/com.unity.multiplayer.mlapi/Runtime/Messaging/RpcQueue/RpcQueueProcessor.cs
@@ -62,6 +62,7 @@ public void ProcessReceiveQueue(NetworkUpdateManager.NetworkUpdateStage currentS
 
                         NetworkingManager.InvokeRpc(currentQueueItem);
                         ProfilerStatManager.rpcsQueueProc.Record();
+                        PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCQueueProcessed);
                         currentQueueItem = CurrentFrame.GetNextQueueItem();
                     }
 
@@ -130,6 +131,7 @@ public void InternalMessagesSendAndFlush()
                                 InternalMessageSender.Send(clientId, MLAPIConstants.MLAPI_ADD_OBJECT, queueItem.channel, PoolStream, queueItem.sendFlags);
                             }
 
+                            PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsSent, queueItem.clientIds.Length);
                             ProfilerStatManager.rpcsSent.Record(queueItem.clientIds.Length);
                             break;
                         }
@@ -140,6 +142,7 @@ public void InternalMessagesSendAndFlush()
                                 InternalMessageSender.Send(clientId, MLAPIConstants.MLAPI_DESTROY_OBJECT, queueItem.channel, PoolStream, queueItem.sendFlags);
                             }
 
+                            PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsSent, queueItem.clientIds.Length);
                             ProfilerStatManager.rpcsSent.Record(queueItem.clientIds.Length);
                             break;
                         }
@@ -228,6 +231,9 @@ private void SendFrameQueueItem(RpcFrameQueueItem queueItem)
                     NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(queueItem.networkId, queueItem.messageData, queueItem.channel);
 
                     //For each packet sent, we want to record how much data we have sent
+
+                    PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)queueItem.streamSize);
+                    PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsSent);
                     ProfilerStatManager.bytesSent.Record((int)queueItem.streamSize);
                     ProfilerStatManager.rpcsSent.Record();
                     break;
@@ -239,10 +245,12 @@ private void SendFrameQueueItem(RpcFrameQueueItem queueItem)
                         NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientid, queueItem.messageData, queueItem.channel);
 
                         //For each packet sent, we want to record how much data we have sent
+                        PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)queueItem.streamSize);
                         ProfilerStatManager.bytesSent.Record((int)queueItem.streamSize);
                     }
 
                     //For each client we send to, we want to record how many RPCs we have sent
+                    PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsSent, queueItem.clientIds.Length);
                     ProfilerStatManager.rpcsSent.Record(queueItem.clientIds.Length);
 
                     break;
diff --git a/com.unity.multiplayer.mlapi/Runtime/Profiling/ITransportProfilerData.cs b/com.unity.multiplayer.mlapi/Runtime/Profiling/ITransportProfilerData.cs
@@ -0,0 +1,9 @@
+﻿using System.Collections.Generic;
+
+namespace MLAPI.Profiling
+{
+    public interface ITransportProfilerData
+    {
+        Dictionary<string, int> GetTransportGetData();
+    }
+}
diff --git a/com.unity.multiplayer.mlapi/Runtime/Profiling/ITransportProfilerData.cs.meta b/com.unity.multiplayer.mlapi/Runtime/Profiling/ITransportProfilerData.cs.meta
diff --git a/com.unity.multiplayer.mlapi/Runtime/Profiling/PerformanceDataManager.cs b/com.unity.multiplayer.mlapi/Runtime/Profiling/PerformanceDataManager.cs
@@ -0,0 +1,38 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+
+namespace MLAPI.Profiling
+{
+    public static class PerformanceDataManager
+    {
+        static PerformanceTickData s_ProfilerData;
+        static int s_TickID;
+
+        public static void BeginNewTick()
+        {
+            s_ProfilerData = new PerformanceTickData
+            {
+                tickID = s_TickID++,
+            };
+        }
+
+        public static void Increment(ProfilerConstants fieldName, int count = 1)
+        {
+            s_ProfilerData.Increment(fieldName, count);
+        }
+
+        public static void AddTransportData(Dictionary<string, int> transportProfilerData)
+        {
+            IEnumerable<KeyValuePair<string, int>> nonDuplicates = transportProfilerData.Where(entry => !s_ProfilerData.tickData.ContainsKey(entry.Key));
+            foreach (KeyValuePair<string, int> entry in nonDuplicates)
+            {
+                s_ProfilerData.tickData.Add(entry.Key, entry.Value);
+            }
+        }
+
+        public static PerformanceTickData GetData()
+        {
+            return s_ProfilerData;
+        }
+    }
+}
diff --git a/com.unity.multiplayer.mlapi/Runtime/Profiling/PerformanceDataManager.cs.meta b/com.unity.multiplayer.mlapi/Runtime/Profiling/PerformanceDataManager.cs.meta
diff --git a/com.unity.multiplayer.mlapi/Runtime/Profiling/PerformanceTickData.cs b/com.unity.multiplayer.mlapi/Runtime/Profiling/PerformanceTickData.cs
@@ -0,0 +1,28 @@
+﻿using System.Collections.Generic;
+
+namespace MLAPI.Profiling
+{
+    public class PerformanceTickData
+    {
+        public int tickID;
+
+        public readonly Dictionary<string, int> tickData = new Dictionary<string, int>();
+
+        public void Increment(ProfilerConstants fieldName, int count = 1)
+        {
+            string fieldStr = fieldName.ToString();
+            if (!tickData.ContainsKey(fieldStr))
+            {
+                tickData[fieldStr] = 0;
+            }
+
+            tickData[fieldStr] += count;
+        }
+
+        public int GetData(ProfilerConstants fieldName)
+        {
+            string fieldString = fieldName.ToString();
+            return tickData.ContainsKey(fieldString) ? tickData[fieldString] : 0;
+        }
+    }
+}
diff --git a/com.unity.multiplayer.mlapi/Runtime/Profiling/PerformanceTickData.cs.meta b/com.unity.multiplayer.mlapi/Runtime/Profiling/PerformanceTickData.cs.meta
diff --git a/com.unity.multiplayer.mlapi/Runtime/Profiling/ProfilerConstants.cs b/com.unity.multiplayer.mlapi/Runtime/Profiling/ProfilerConstants.cs
@@ -0,0 +1,21 @@
+namespace MLAPI.Profiling
+{
+    public enum ProfilerConstants
+    {
+        NumberOfConnections,
+        ReceiveTickRate,
+
+        NumberOfNamedMessages,
+        NumberOfUnnamedMessages,
+        NumberBytesSent,
+        NumberBytesReceived,
+        NumberNetworkVarsReceived,
+        NumberOfRPCsSent,
+        NumberOfRPCsReceived,
+        NumberOfRPCBatchesSent,
+        NumberOfRPCBatchesReceived,
+        NumberOfRPCQueueProcessed,
+        NumberOfRPCsInQueueSize,
+        NumberOfRPCsOutQueueSize,
+    }
+}
diff --git a/com.unity.multiplayer.mlapi/Runtime/Profiling/ProfilerConstants.cs.meta b/com.unity.multiplayer.mlapi/Runtime/Profiling/ProfilerConstants.cs.meta

Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,10 @@ public class NetworkingManager : UpdateLoopBehaviour`
`72`	`72`	`#endif`
`73`	`73`	`public RpcQueueContainer rpcQueueContainer { get; private set; }`
`74`	`74`
	`75`	`+ public delegate void PerformanceDataEventHandler(PerformanceTickData profilerData);`
	`76`	`+`
	`77`	`+ public event PerformanceDataEventHandler OnPerformanceDataEvent;`
	`78`	`+`
`75`	`79`	`/// <summary>`
`76`	`80`	`/// A synchronized time, represents the time in seconds since the server application started. Is replicated across all clients`
`77`	`81`	`/// </summary>`
`@@ -735,11 +739,14 @@ private void Awake()`
`735`	`739`	`/// </summary>`
`736`	`740`	`private void NetworkPreUpdate()`
`737`	`741`	`{`
	`742`	`+ PerformanceDataManager.BeginNewTick();`
	`743`	`+`
`738`	`744`	`if (IsListening)`
`739`	`745`	`{`
`740`	`746`	`// Process received data`
`741`	`747`	`if ((NetworkTime - m_LastReceiveTickTime >= (1f / NetworkConfig.ReceiveTickrate)) \|\| NetworkConfig.ReceiveTickrate <= 0)`
`742`	`748`	`{`
	`749`	`+ PerformanceDataManager.Increment(ProfilerConstants.ReceiveTickRate);`
`743`	`750`	`ProfilerStatManager.rcvTickRate.Record();`
`744`	`751`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`745`	`752`	`s_ReceiveTick.Begin();`
`@@ -853,6 +860,15 @@ private void NetworkUpdate()`
`853`	`860`	`currentNetworkTimeOffset += Mathf.Clamp(networkTimeOffset - currentNetworkTimeOffset, -maxDelta, maxDelta);`
`854`	`861`	`}`
`855`	`862`	`}`
	`863`	`+`
	`864`	`+ var profileTransport = NetworkConfig.NetworkTransport as ITransportProfilerData;`
	`865`	`+ if (profileTransport != null)`
	`866`	`+ {`
	`867`	`+ var transportProfilerData = profileTransport.GetTransportGetData();`
	`868`	`+ PerformanceDataManager.AddTransportData(transportProfilerData);`
	`869`	`+ }`
	`870`	`+`
	`871`	`+ OnPerformanceDataEvent?.Invoke(PerformanceDataManager.GetData());`
`856`	`872`	`}`
`857`	`873`
`858`	`874`	`internal void UpdateNetworkTime(ulong clientId, float netTime, float receiveTime, bool warp = false)`
`@@ -906,6 +922,7 @@ internal IEnumerator TimeOutSwitchSceneProgress(SceneSwitchProgress switchSceneP`
`906`	`922`
`907`	`923`	`private void HandleRawTransportPoll(NetEventType eventType, ulong clientId, Channel channel, ArraySegment<byte> payload, float receiveTime)`
`908`	`924`	`{`
	`925`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberBytesReceived, payload.Count);`
`909`	`926`	`ProfilerStatManager.bytesRcvd.Record(payload.Count);`
`910`	`927`	`switch (eventType)`
`911`	`928`	`{`
`@@ -1166,6 +1183,7 @@ internal void HandleIncomingData(ulong clientId, Channel channel, ArraySegment<b`
`1166`	`1183`	`{`
`1167`	`1184`	`m_RpcBatcher.ReceiveItems(messageStream, ReceiveCallback, RpcQueueContainer.QueueItemType.ServerRpc, clientId, receiveTime);`
`1168`	`1185`	`ProfilerStatManager.rpcBatchesRcvd.Record();`
	`1186`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCBatchesReceived);`
`1169`	`1187`	`}`
`1170`	`1188`	`else`
`1171`	`1189`	`{`
`@@ -1188,6 +1206,7 @@ internal void HandleIncomingData(ulong clientId, Channel channel, ArraySegment<b`
`1188`	`1206`	`{`
`1189`	`1207`	`m_RpcBatcher.ReceiveItems(messageStream, ReceiveCallback, RpcQueueContainer.QueueItemType.ClientRpc, clientId, receiveTime);`
`1190`	`1208`	`ProfilerStatManager.rpcBatchesRcvd.Record();`
	`1209`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCBatchesReceived);`
`1191`	`1210`	`}`
`1192`	`1211`	`else`
`1193`	`1212`	`{`
`@@ -1339,6 +1358,7 @@ public void DisconnectClient(ulong clientId)`
`1339`	`1358`	`{`
`1340`	`1359`	`if (ConnectedClientsList[i].ClientId == clientId) {`
`1341`	`1360`	`ConnectedClientsList.RemoveAt(i);`
	`1361`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfConnections, -1);`
`1342`	`1362`	`ProfilerStatManager.connections.Record(-1);`
`1343`	`1363`	`}`
`1344`	`1364`	`}`
`@@ -1404,6 +1424,7 @@ internal void OnClientDisconnectFromServer(ulong clientId)`
`1404`	`1424`	`if (ConnectedClientsList[i].ClientId == clientId)`
`1405`	`1425`	`{`
`1406`	`1426`	`ConnectedClientsList.RemoveAt(i);`
	`1427`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfConnections, -1);`
`1407`	`1428`	`ProfilerStatManager.connections.Record(-1);`
`1408`	`1429`	`break;`
`1409`	`1430`	`}`
`@@ -1452,6 +1473,7 @@ internal void HandleApproval(ulong clientId, bool createPlayerObject, ulong? pla`
`1452`	`1473`	`ConnectedClients.Add(clientId, client);`
`1453`	`1474`	`ConnectedClientsList.Add(client);`
`1454`	`1475`
	`1476`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfConnections);`
`1455`	`1477`	`ProfilerStatManager.connections.Record();`
`1456`	`1478`
`1457`	`1479`	`// This packet is unreliable, but if it gets through it should provide a much better sync than the potentially huge approval message.`
Original file line number	Diff line number	Diff line change
`@@ -694,13 +694,15 @@ internal static void RPCReceiveQueueItem(ulong clientId, Stream stream, float re`
`694`	`694`	`}`
`695`	`695`
`696`	`696`	`ProfilerStatManager.rpcsRcvd.Record();`
	`697`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsReceived);`
`697`	`698`
`698`	`699`	`var rpcQueueContainer = NetworkingManager.Singleton.rpcQueueContainer;`
`699`	`700`	`rpcQueueContainer.AddQueueItemToInboundFrame(queueItemType, receiveTime, clientId, (BitStream)stream);`
`700`	`701`	`}`
`701`	`702`
`702`	`703`	`internal static void HandleUnnamedMessage(ulong clientId, Stream stream)`
`703`	`704`	`{`
	`705`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfUnnamedMessages);`
`704`	`706`	`ProfilerStatManager.unnamedMessage.Record();`
`705`	`707`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`706`	`708`	`s_HandleUnnamedMessage.Begin();`
`@@ -713,6 +715,7 @@ internal static void HandleUnnamedMessage(ulong clientId, Stream stream)`
`713`	`715`
`714`	`716`	`internal static void HandleNamedMessage(ulong clientId, Stream stream)`
`715`	`717`	`{`
	`718`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfNamedMessages);`
`716`	`719`	`ProfilerStatManager.namedMessage.Record();`
`717`	`720`	`#if DEVELOPMENT_BUILD \|\| UNITY_EDITOR`
`718`	`721`	`s_HandleNamedMessage.Begin();`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ internal static void Send(ulong clientId, byte messageType, Channel channel, Bit`
`26`	`26`
`27`	`27`	`NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);`
`28`	`28`	`ProfilerStatManager.bytesSent.Record((int)stream.Length);`
	`29`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)stream.Length);`
`29`	`30`
`30`	`31`	`NetworkProfiler.EndEvent();`
`31`	`32`	`}`
`@@ -57,6 +58,7 @@ internal static void Send(byte messageType, Channel channel, BitStream messageSt`
`57`	`58`
`58`	`59`	`NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);`
`59`	`60`	`ProfilerStatManager.bytesSent.Record((int)stream.Length);`
	`61`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)stream.Length);`
`60`	`62`	`}`
`61`	`63`	`NetworkProfiler.EndEvent();`
`62`	`64`	`}`
`@@ -95,6 +97,7 @@ internal static void Send(byte messageType, Channel channel, List<ulong> clientI`
`95`	`97`
`96`	`98`	`NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientIds[i], new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);`
`97`	`99`	`ProfilerStatManager.bytesSent.Record((int)stream.Length);`
	`100`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)stream.Length);`
`98`	`101`	`}`
`99`	`102`	`NetworkProfiler.EndEvent();`
`100`	`103`	`}`
`@@ -131,6 +134,7 @@ internal static void Send(byte messageType, Channel channel, ulong clientIdToIgn`
`131`	`134`
`132`	`135`	`NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);`
`133`	`136`	`ProfilerStatManager.bytesSent.Record((int)stream.Length);`
	`137`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, (int)stream.Length);`
`134`	`138`	`}`
`135`	`139`	`NetworkProfiler.EndEvent();`
`136`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -149,6 +149,8 @@ public void QueueItem(in RpcFrameQueueItem queueItem)`
`149`	`149`
`150`	`150`	`ProfilerStatManager.bytesSent.Record(queueItem.messageData.Count);`
`151`	`151`	`ProfilerStatManager.rpcsSent.Record();`
	`152`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberBytesSent, queueItem.messageData.Count);`
	`153`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsSent);`
`152`	`154`	`}`
`153`	`155`	`}`
`154`	`156`
`@@ -178,6 +180,7 @@ public void SendItems(int thresholdBytes, SendCallbackType sendCallback)`
`178`	`180`	`entry.Value.Stream.Position = 0;`
`179`	`181`	`entry.Value.IsEmpty = true;`
`180`	`182`	`ProfilerStatManager.rpcBatchesSent.Record();`
	`183`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCBatchesSent);`
`181`	`184`	`}`
`182`	`185`	`}`
`183`	`186`	`}`
Original file line number	Diff line number	Diff line change
`@@ -251,10 +251,12 @@ public void AdvanceFrameHistory(QueueHistoryFrame.QueueFrameType queueType)`
`251`	`251`	`if (queueType == QueueHistoryFrame.QueueFrameType.Inbound)`
`252`	`252`	`{`
`253`	`253`	`ProfilerStatManager.rpcInQueueSize.Record((int)queueHistoryItem.totalSize);`
	`254`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsInQueueSize, (int)queueHistoryItem.totalSize);`
`254`	`255`	`}`
`255`	`256`	`else`
`256`	`257`	`{`
`257`	`258`	`ProfilerStatManager.rpcOutQueueSize.Record((int)queueHistoryItem.totalSize);`
	`259`	`+ PerformanceDataManager.Increment(ProfilerConstants.NumberOfRPCsOutQueueSize, (int)queueHistoryItem.totalSize);`
`258`	`260`	`}`
`259`	`261`	`}`
`260`	`262`