fix: dispatch metrics once per frame instead of once per tick (MTT-1391) (#1261)

* fix: dispatch metrics once per frame instead of once per tick (MTT-1391)

* fixed encoding

* fixed bug where a network manager which has executed a single tick would not dispatch the first frame after it was reset

* Updated to use a dirty flag in the metrics instead of a tick check in the network manager

Co-authored-by: Matt Walsh <69258106+mattwalsh-unity@users.noreply.github.com>

Author: becksebenius-unity

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

@@ -1176,6 +1176,7 @@ private void OnNetworkPreUpdate()
         private void OnNetworkPostLateUpdate()
         {
             m_MessagingSystem.ProcessSendQueues();
+            NetworkMetrics.DispatchFrame();
         }
 
         /// <summary>
@@ -1194,8 +1195,6 @@ private void OnNetworkManagerTick()
             {
                 SyncTime();
             }
-
-            NetworkMetrics.DispatchFrame();
         }
 
         private void SendConnectionRequest()

com.unity.netcode.gameobjects/Runtime/Metrics/NetworkMetrics.cs

@@ -37,6 +37,7 @@ internal class NetworkMetrics : INetworkMetrics
         readonly EventMetric<ServerLogEvent> m_ServerLogReceivedEvent = new EventMetric<ServerLogEvent>(NetworkMetricTypes.ServerLogReceived.Id);
         readonly EventMetric<SceneEventMetric> m_SceneEventSentEvent = new EventMetric<SceneEventMetric>(NetworkMetricTypes.SceneEventSent.Id);
         readonly EventMetric<SceneEventMetric> m_SceneEventReceivedEvent = new EventMetric<SceneEventMetric>(NetworkMetricTypes.SceneEventReceived.Id);
+        private bool m_Dirty;
 
         readonly Dictionary<ulong, NetworkObjectIdentifier> m_NetworkGameObjects = new Dictionary<ulong, NetworkObjectIdentifier>();
 
@@ -87,16 +88,19 @@ public void TrackNetworkObject(NetworkObject networkObject)
         public void TrackNetworkMessageSent(ulong receivedClientId, string messageType, long bytesCount)
         {
             m_NetworkMessageSentEvent.Mark(new NetworkMessageEvent(new ConnectionInfo(receivedClientId), messageType, bytesCount));
+            MarkDirty();
         }
 
         public void TrackNetworkMessageReceived(ulong senderClientId, string messageType, long bytesCount)
         {
             m_NetworkMessageReceivedEvent.Mark(new NetworkMessageEvent(new ConnectionInfo(senderClientId), messageType, bytesCount));
+            MarkDirty();
         }
 
         public void TrackNamedMessageSent(ulong receiverClientId, string messageName, long bytesCount)
         {
             m_NamedMessageSentEvent.Mark(new NamedMessageEvent(new ConnectionInfo(receiverClientId), messageName, bytesCount));
+            MarkDirty();
         }
 
         public void TrackNamedMessageSent(IReadOnlyCollection<ulong> receiverClientIds, string messageName, long bytesCount)
@@ -110,11 +114,13 @@ public void TrackNamedMessageSent(IReadOnlyCollection<ulong> receiverClientIds,
         public void TrackNamedMessageReceived(ulong senderClientId, string messageName, long bytesCount)
         {
             m_NamedMessageReceivedEvent.Mark(new NamedMessageEvent(new ConnectionInfo(senderClientId), messageName, bytesCount));
+            MarkDirty();
         }
 
         public void TrackUnnamedMessageSent(ulong receiverClientId, long bytesCount)
         {
             m_UnnamedMessageSentEvent.Mark(new UnnamedMessageEvent(new ConnectionInfo(receiverClientId), bytesCount));
+            MarkDirty();
         }
 
         public void TrackUnnamedMessageSent(IReadOnlyCollection<ulong> receiverClientIds, long bytesCount)
@@ -128,6 +134,7 @@ public void TrackUnnamedMessageSent(IReadOnlyCollection<ulong> receiverClientIds
         public void TrackUnnamedMessageReceived(ulong senderClientId, long bytesCount)
         {
             m_UnnamedMessageReceivedEvent.Mark(new UnnamedMessageEvent(new ConnectionInfo(senderClientId), bytesCount));
+            MarkDirty();
         }
 
         public void TrackNetworkVariableDeltaSent(
@@ -145,6 +152,7 @@ public void TrackNetworkVariableDeltaSent(
                     variableName,
                     networkBehaviourName,
                     bytesCount));
+            MarkDirty();
         }
 
         public void TrackNetworkVariableDeltaReceived(
@@ -162,37 +170,44 @@ public void TrackNetworkVariableDeltaReceived(
                     variableName,
                     networkBehaviourName,
                     bytesCount));
+            MarkDirty();
         }
 
         public void TrackOwnershipChangeSent(ulong receiverClientId, ulong networkObjectId, string gameObjectName, long bytesCount)
         {
             m_OwnershipChangeSentEvent.Mark(new OwnershipChangeEvent(new ConnectionInfo(receiverClientId), new NetworkObjectIdentifier(gameObjectName, networkObjectId), bytesCount));
+            MarkDirty();
         }
 
         public void TrackOwnershipChangeReceived(ulong senderClientId, ulong networkObjectId, string gameObjectName, long bytesCount)
         {
             m_OwnershipChangeReceivedEvent.Mark(new OwnershipChangeEvent(new ConnectionInfo(senderClientId),
                 new NetworkObjectIdentifier(gameObjectName, networkObjectId), bytesCount));
+            MarkDirty();
         }
 
         public void TrackObjectSpawnSent(ulong receiverClientId, ulong networkObjectId, string gameObjectName, long bytesCount)
         {
             m_ObjectSpawnSentEvent.Mark(new ObjectSpawnedEvent(new ConnectionInfo(receiverClientId), new NetworkObjectIdentifier(gameObjectName, networkObjectId), bytesCount));
+            MarkDirty();
         }
 
         public void TrackObjectSpawnReceived(ulong senderClientId, ulong networkObjectId, string gameObjectName, long bytesCount)
         {
             m_ObjectSpawnReceivedEvent.Mark(new ObjectSpawnedEvent(new ConnectionInfo(senderClientId), new NetworkObjectIdentifier(gameObjectName, networkObjectId), bytesCount));
+            MarkDirty();
         }
 
         public void TrackObjectDestroySent(ulong receiverClientId, ulong networkObjectId, string gameObjectName, long bytesCount)
         {
             m_ObjectDestroySentEvent.Mark(new ObjectDestroyedEvent(new ConnectionInfo(receiverClientId), new NetworkObjectIdentifier(gameObjectName, networkObjectId), bytesCount));
+            MarkDirty();
         }
 
         public void TrackObjectDestroyReceived(ulong senderClientId, ulong networkObjectId, string gameObjectName, long bytesCount)
         {
             m_ObjectDestroyReceivedEvent.Mark(new ObjectDestroyedEvent(new ConnectionInfo(senderClientId), new NetworkObjectIdentifier(gameObjectName, networkObjectId), bytesCount));
+            MarkDirty();
         }
 
         public void TrackRpcSent(
@@ -214,6 +229,7 @@ public void TrackRpcSent(
                     rpcName,
                     networkBehaviourName,
                     bytesCount));
+            MarkDirty();
         }
 
         public void TrackRpcSent(
@@ -247,16 +263,19 @@ public void TrackRpcReceived(
                     rpcName,
                     networkBehaviourName,
                     bytesCount));
+            MarkDirty();
         }
 
         public void TrackServerLogSent(ulong receiverClientId, uint logType, long bytesCount)
         {
             m_ServerLogSentEvent.Mark(new ServerLogEvent(new ConnectionInfo(receiverClientId), (Unity.Multiplayer.Tools.MetricTypes.LogLevel)logType, bytesCount));
+            MarkDirty();
         }
 
         public void TrackServerLogReceived(ulong senderClientId, uint logType, long bytesCount)
         {
             m_ServerLogReceivedEvent.Mark(new ServerLogEvent(new ConnectionInfo(senderClientId), (Unity.Multiplayer.Tools.MetricTypes.LogLevel)logType, bytesCount));
+            MarkDirty();
         }
 
         public void TrackSceneEventSent(IReadOnlyList<ulong> receiverClientIds, uint sceneEventType, string sceneName, long bytesCount)
@@ -270,16 +289,27 @@ public void TrackSceneEventSent(IReadOnlyList<ulong> receiverClientIds, uint sce
         public void TrackSceneEventSent(ulong receiverClientId, uint sceneEventType, string sceneName, long bytesCount)
         {
             m_SceneEventSentEvent.Mark(new SceneEventMetric(new ConnectionInfo(receiverClientId), (SceneEventType)sceneEventType, sceneName, bytesCount));
+            MarkDirty();
         }
 
         public void TrackSceneEventReceived(ulong senderClientId, uint sceneEventType, string sceneName, long bytesCount)
         {
             m_SceneEventReceivedEvent.Mark(new SceneEventMetric(new ConnectionInfo(senderClientId), (SceneEventType)sceneEventType, sceneName, bytesCount));
+            MarkDirty();
         }
 
         public void DispatchFrame()
         {
-            Dispatcher.Dispatch();
+            if (m_Dirty)
+            {
+                Dispatcher.Dispatch();
+                m_Dirty = false;
+            }
+        }
+
+        private void MarkDirty()
+        {
+            m_Dirty = true;
         }
     }
 

com.unity.netcode.gameobjects/Tests/Runtime/Metrics/MetricsDispatchTests.cs

@@ -0,0 +1,162 @@
+#if MULTIPLAYER_TOOLS
+using System;
+using System.Collections;
+using NUnit.Framework;
+using Unity.Collections;
+using Unity.Multiplayer.Tools.NetStats;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests.Metrics
+{
+    public class MetricsDispatchTests
+    {
+        private class MockMetricsObserver : IMetricObserver
+        {
+            public Action OnObserve;
+            public void Observe(MetricCollection collection) => OnObserve?.Invoke();
+        }
+
+        private int m_NumTicks;
+        private int m_NumDispatches;
+
+        private NetworkManager m_NetworkManager;
+        private NetworkTimeSystem timeSystem => m_NetworkManager.NetworkTimeSystem;
+        private NetworkTickSystem tickSystem => m_NetworkManager.NetworkTickSystem;
+        private uint m_TickRate = 1;
+
+        [SetUp]
+        public void SetUp()
+        {
+            Assert.IsTrue(NetworkManagerHelper.StartNetworkManager(
+                out m_NetworkManager,
+                NetworkManagerHelper.NetworkManagerOperatingMode.Host,
+                new NetworkConfig()
+            {
+                TickRate = m_TickRate
+            }));
+
+            InitNetworkManager();
+
+            var networkMetrics = m_NetworkManager.NetworkMetrics as NetworkMetrics;
+            networkMetrics.Dispatcher.RegisterObserver(new MockMetricsObserver()
+            {
+                OnObserve = ()=> m_NumDispatches++
+            });
+        }
+
+        private void InitNetworkManager()
+        {
+            tickSystem.Tick += ()=> m_NumTicks++;
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            NetworkManagerHelper.ShutdownNetworkManager();
+            m_NumTicks = default;
+            m_NumDispatches = default;
+            m_NetworkManager = default;
+        }
+
+        [UnityTest]
+        public IEnumerator GivenMetricsTracked_MultipleTicksPass_OneDispatchOccurs()
+        {
+            SendMetric();
+            AdvanceTicks(2);
+
+            // Wait one frame so dispatch occurs
+            yield return null;
+
+            Assert.AreEqual(2, m_NumTicks);
+            Assert.AreEqual(1, m_NumDispatches);
+        }
+
+        [UnityTest]
+        public IEnumerator GivenMetricsTracked_OneTickPasses_OneDispatchOccurs()
+        {
+            SendMetric();
+            AdvanceTicks(1);
+
+            // Wait one frame so dispatch occurs
+            yield return null;
+
+            Assert.AreEqual(1, m_NumTicks);
+            Assert.AreEqual(1, m_NumDispatches);
+        }
+
+        [UnityTest]
+        public IEnumerator GivenMetricsTracked_ZeroTicksPass_OneDispatchOccurs()
+        {
+            SendMetric();
+
+            yield return null;
+
+            Assert.AreEqual(0, m_NumTicks);
+            Assert.AreEqual(1, m_NumDispatches);
+        }
+
+        [UnityTest]
+        public IEnumerator GivenNoMetricsTracked_ZeroTicksPass_NoDispatchOccurs()
+        {
+            yield return null;
+
+            Assert.AreEqual(0, m_NumTicks);
+            Assert.AreEqual(0, m_NumDispatches);
+        }
+
+        [UnityTest]
+        public IEnumerator GivenNoMetricsTracked_MultipleTicksPass_NoDispatchOccurs()
+        {
+            AdvanceTicks(2);
+
+            yield return null;
+
+            Assert.AreEqual(2, m_NumTicks);
+            Assert.AreEqual(0, m_NumDispatches);
+        }
+
+        [UnityTest]
+        // This tests a regression where dispatches would not occur when the network manager was reset
+        //     after a single tick and then started again. The first frame would not dispatch even though it should
+        // This is likely not an edge case after refactoring to use dirty flags in the dispatcher
+        //     but the test should still pass
+        public IEnumerator GivenReinitializedNetworkManagerAfterOneTickExecuted_WhenFirstTickExecuted_MetricsDispatch()
+        {
+            SendMetric();
+            AdvanceTicks(1);
+            yield return null;
+
+            Assert.AreEqual(1, m_NumTicks);
+            Assert.AreEqual(1, m_NumDispatches);
+
+            m_NetworkManager.Shutdown();
+            m_NetworkManager.StartHost();
+            InitNetworkManager();
+
+            SendMetric();
+            AdvanceTicks(1);
+            yield return null;
+
+            Assert.AreEqual(2, m_NumTicks);
+            Assert.AreEqual(2, m_NumDispatches);
+        }
+
+        private void AdvanceTicks(int numTicks)
+        {
+            timeSystem.Advance(1f / m_TickRate * (numTicks + 0.1f));
+            tickSystem.UpdateTick(timeSystem.LocalTime, timeSystem.ServerTime);
+        }
+
+        private void SendMetric()
+        {
+            var writer = new FastBufferWriter(1300, Allocator.Temp);
+            using (writer)
+            {
+                m_NetworkManager.CustomMessagingManager.SendNamedMessage("FakeMetric", m_NetworkManager.LocalClientId, writer);
+            }
+        }
+
+    }
+}
+#endif