feat: UTP Packet Loss tracking [MTT-1654] (#1833)

* feat: UTP Packet Loss tracking [MTT-1654]

* Added missing ifdef, and changed name to better reflect the value given

* Dispatching percentage as not multiplied by 100 (value between 0 and 1)

* Tweaked test to use constants

* Updated reference for tools in testproject-tools-integration

* Fix whitespace

Author: JS Fauteux

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

@@ -87,12 +87,14 @@ void TrackRpcReceived(
 
         void TrackPacketReceived(uint packetCount);
 
-        void TrackRttToServer(int rtt);
+        void UpdateRttToServer(int rtt);
 
         void UpdateNetworkObjectsCount(int count);
 
         void UpdateConnectionsCount(int count);
 
+        void UpdatePacketLoss(float packetLoss);
+
         void DispatchFrame();
     }
 }

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

@@ -87,6 +87,7 @@ private static string GetSceneEventTypeName(uint typeCode)
         {
             ShouldResetOnDispatch = true,
         };
+        private readonly Gauge m_PacketLossGauge = new Gauge(NetworkMetricTypes.PacketLoss.Id);
 #endif
 
         private ulong m_NumberOfMetricsThisFrame;
@@ -110,6 +111,7 @@ public NetworkMetrics()
                 .WithGauges(m_RttToServerGauge)
                 .WithGauges(m_NetworkObjectsGauge)
                 .WithGauges(m_ConnectionsGauge)
+                .WithGauges(m_PacketLossGauge)
 #endif
                 .Build();
 
@@ -462,7 +464,7 @@ public void TrackPacketReceived(uint packetCount)
 #endif
         }
 
-        public void TrackRttToServer(int rttMilliseconds)
+        public void UpdateRttToServer(int rttMilliseconds)
         {
 #if MULTIPLAYER_TOOLS_1_0_0_PRE_7
             if (!CanSendMetrics)
@@ -498,6 +500,18 @@ public void UpdateConnectionsCount(int count)
 #endif
         }
 
+        public void UpdatePacketLoss(float packetLoss)
+        {
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+            if (!CanSendMetrics)
+            {
+                return;
+            }
+
+            m_PacketLossGauge.Set(packetLoss);
+#endif
+        }
+
         public void DispatchFrame()
         {
             s_FrameDispatch.Begin();

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

@@ -145,7 +145,7 @@ public void TrackPacketReceived(uint packetCount)
         {
         }
 
-        public void TrackRttToServer(int rtt)
+        public void UpdateRttToServer(int rtt)
         {
         }
 
@@ -157,6 +157,10 @@ public void UpdateConnectionsCount(int count)
         {
         }
 
+        public void UpdatePacketLoss(float packetLoss)
+        {
+        }
+
         public void DispatchFrame()
         {
         }

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

@@ -710,7 +710,10 @@ private void ExtractNetworkMetricsForClient(ulong transportClientId)
             ExtractNetworkMetricsFromPipeline(m_ReliableSequencedPipeline, networkConnection);
 
             var rttValue = NetworkManager.IsServer ? 0 : ExtractRtt(networkConnection);
-            NetworkMetrics.TrackRttToServer(rttValue);
+            NetworkMetrics.UpdateRttToServer(rttValue);
+
+            var packetLoss = NetworkManager.IsServer ? 0 : ExtractPacketLoss(networkConnection);
+            NetworkMetrics.UpdatePacketLoss(packetLoss);
         }
 
         private void ExtractNetworkMetricsFromPipeline(NetworkPipeline pipeline, NetworkConnection networkConnection)
@@ -758,6 +761,32 @@ private int ExtractRtt(NetworkConnection networkConnection)
             }
         }
 
+        private float ExtractPacketLoss(NetworkConnection networkConnection)
+        {
+            if (m_Driver.GetConnectionState(networkConnection) != NetworkConnection.State.Connected)
+            {
+                return 0f;
+            }
+
+            m_Driver.GetPipelineBuffers(m_ReliableSequencedPipeline,
+                NetworkPipelineStageCollection.GetStageId(typeof(ReliableSequencedPipelineStage)),
+                networkConnection,
+                out _,
+                out _,
+                out var sharedBuffer);
+
+            unsafe
+            {
+                var sharedContext = (ReliableUtility.SharedContext*)sharedBuffer.GetUnsafePtr();
+
+                var packetReceived = (float)sharedContext->stats.PacketsReceived;
+                var packetDropped = (float)sharedContext->stats.PacketsDropped;
+                var packetLoss = packetReceived > 0 ? packetDropped / packetReceived : 0;
+
+                return packetLoss;
+            }
+        }
+
         private static unsafe ulong ParseClientId(NetworkConnection utpConnectionId)
         {
             return *(ulong*)&utpConnectionId;

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

@@ -0,0 +1,89 @@
+#if MULTIPLAYER_TOOLS
+#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
+
+using System;
+using System.Collections;
+using NUnit.Framework;
+using Unity.Collections;
+using Unity.Multiplayer.Tools.MetricTypes;
+using Unity.Netcode.TestHelpers.Runtime;
+using Unity.Netcode.TestHelpers.Runtime.Metrics;
+using Unity.Netcode.Transports.UTP;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests.Metrics
+{
+    public class PacketLossMetricsTests : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 1;
+        private readonly int m_PacketLossRate = 25;
+        private int m_DropInterval = 5;
+
+        public PacketLossMetricsTests()
+            : base(HostOrServer.Server)
+        {}
+
+        protected override void OnOneTimeSetup()
+        {
+            m_NetworkTransport = NetcodeIntegrationTestHelpers.InstanceTransport.UTP;
+        }
+
+        protected override void OnServerAndClientsCreated()
+        {
+            var clientTransport = (UnityTransport)m_ClientNetworkManagers[0].NetworkConfig.NetworkTransport;
+            clientTransport.SetDebugSimulatorParameters(0, 0, m_PacketLossRate);
+
+            base.OnServerAndClientsCreated();
+        }
+
+        [UnityTest]
+        public IEnumerator TrackPacketLossAsServer()
+        {
+            var waitForPacketLossMetric = new WaitForGaugeMetricValues((m_ServerNetworkManager.NetworkMetrics as NetworkMetrics).Dispatcher,
+                NetworkMetricTypes.PacketLoss,
+                metric => metric == 0.0d);
+
+            for (int i = 0; i < 1000; ++i)
+            {
+                using (var writer = new FastBufferWriter(sizeof(byte), Allocator.Persistent))
+                {
+                    writer.WriteByteSafe(42);
+                    m_ServerNetworkManager.CustomMessagingManager.SendNamedMessage("Test", m_ServerNetworkManager.ConnectedClientsIds, writer);
+                }
+            }
+
+            yield return waitForPacketLossMetric.WaitForMetricsReceived();
+
+            var packetLossValue = waitForPacketLossMetric.AssertMetricValueHaveBeenFound();
+            Assert.AreEqual(0d, packetLossValue);
+        }
+
+        [UnityTest]
+        public IEnumerator TrackPacketLossAsClient()
+        {
+            double packetLossRate = m_PacketLossRate/100d;
+            var clientNetworkManager = m_ClientNetworkManagers[0];
+            var waitForPacketLossMetric = new WaitForGaugeMetricValues((clientNetworkManager.NetworkMetrics as NetworkMetrics).Dispatcher,
+                NetworkMetricTypes.PacketLoss,
+                metric => Math.Abs(metric - packetLossRate) < Double.Epsilon);
+
+            for (int i = 0; i < 1000; ++i)
+            {
+                using (var writer = new FastBufferWriter(sizeof(byte), Allocator.Persistent))
+                {
+                    writer.WriteByteSafe(42);
+                    m_ServerNetworkManager.CustomMessagingManager.SendNamedMessage("Test", m_ServerNetworkManager.ConnectedClientsIds, writer);
+                }
+            }
+
+            yield return waitForPacketLossMetric.WaitForMetricsReceived();
+
+            var packetLossValue = waitForPacketLossMetric.AssertMetricValueHaveBeenFound();
+            Assert.AreEqual(packetLossRate, packetLossValue);
+        }
+    }
+}
+
+#endif
+#endif

com.unity.netcode.gameobjects/Tests/Runtime/Metrics/PacketLossMetricsTests.cs.meta

@@ -2,7 +2,7 @@
     "registry": "https://artifactory.prd.cds.internal.unity3d.com/artifactory/api/npm/upm-candidates",
     "dependencies": {
         "com.unity.ide.rider": "3.0.7",
-        "com.unity.multiplayer.tools": "https://github.com/Unity-Technologies/com.unity.multiplayer.tools.git#cfb8fd305c3e46bb1251b40ec5f6cb621a267e7f",
+        "com.unity.multiplayer.tools": "https://github.com/Unity-Technologies/com.unity.multiplayer.tools.git#f935904741c349dc41ba24fda6639041128e8f19",
         "com.unity.netcode.gameobjects": "file:../../com.unity.netcode.gameobjects",
         "com.unity.test-framework": "1.1.31",
         "com.unity.test-framework.performance": "2.8.0-preview",
@@ -41,4 +41,4 @@
     "testables": [
         "com.unity.netcode.gameobjects"
     ]
-}
+}