feat: Add metrics for transport bytes sent and received

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

@@ -1137,6 +1137,8 @@ private IEnumerator ApprovalTimeout(ulong clientId)
         private void HandleRawTransportPoll(NetworkEvent networkEvent, ulong clientId, NetworkChannel networkChannel,
             ArraySegment<byte> payload, float receiveTime)
         {
+            NetworkMetrics.TrackTransportBytesReceived(payload.Count);
+
             switch (networkEvent)
             {
                 case NetworkEvent.Connect:
@@ -1220,6 +1222,7 @@ internal void HandleIncomingData(ulong clientId, NetworkChannel networkChannel,
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             s_HandleIncomingData.Begin();
 #endif
+
             if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
             {
                 NetworkLog.LogInfo("Unwrapping Data Header");

com.unity.netcode.gameobjects/Runtime/Messaging/MessageQueue/MessageQueueProcessor.cs

@@ -283,6 +283,8 @@ private void SendCallback(ulong clientId, MessageBatcher.SendStream sendStream)
             {
                 channel = NetworkChannel.Fragmented;
             }
+
+            m_MessageQueueContainer.NetworkManager.NetworkMetrics.TrackTransportBytesSent(length);
             m_MessageQueueContainer.NetworkManager.NetworkConfig.NetworkTransport.Send(clientId, sendBuffer, channel);
         }
 
@@ -307,13 +309,15 @@ private void SendFrameQueueItem(MessageFrameItem item)
                 case MessageQueueContainer.MessageType.ServerRpc:
                     // TODO: Can we remove this special case for server RPCs?
                     {
+                        m_MessageQueueContainer.NetworkManager.NetworkMetrics.TrackTransportBytesSent(item.MessageData.Count);
                         m_MessageQueueContainer.NetworkManager.NetworkConfig.NetworkTransport.Send(item.NetworkId, item.MessageData, channel);
                         break;
                     }
                 default:
                     {
                         foreach (ulong clientid in item.ClientNetworkIds)
                         {
+                            m_MessageQueueContainer.NetworkManager.NetworkMetrics.TrackTransportBytesSent(item.MessageData.Count);
                             m_MessageQueueContainer.NetworkManager.NetworkConfig.NetworkTransport.Send(clientid, item.MessageData, channel);
                         }
 

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

@@ -4,6 +4,10 @@ namespace Unity.Netcode
 {
     internal interface INetworkMetrics
     {
+        void TrackTransportBytesSent(long bytesCount);
+
+        void TrackTransportBytesReceived(long bytesCount);
+
         void TrackNetworkObject(NetworkObject networkObject);
 
         void TrackNamedMessageSent(ulong receiverClientId, string messageName, long bytesCount);

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

@@ -8,6 +8,15 @@ namespace Unity.Netcode
 {
     internal class NetworkMetrics : INetworkMetrics
     {
+        readonly Counter m_TransportBytesSent = new Counter(NetworkMetricTypes.TotalBytesSent.Id)
+        {
+            ShouldResetOnDispatch = true,
+        };
+        readonly Counter m_TransportBytesReceived = new Counter(NetworkMetricTypes.TotalBytesReceived.Id)
+        {
+            ShouldResetOnDispatch = true,
+        };
+
         readonly EventMetric<NamedMessageEvent> m_NamedMessageSentEvent = new EventMetric<NamedMessageEvent>(NetworkMetricTypes.NamedMessageSent.Id);
         readonly EventMetric<NamedMessageEvent> m_NamedMessageReceivedEvent = new EventMetric<NamedMessageEvent>(NetworkMetricTypes.NamedMessageReceived.Id);
         readonly EventMetric<UnnamedMessageEvent> m_UnnamedMessageSentEvent = new EventMetric<UnnamedMessageEvent>(NetworkMetricTypes.UnnamedMessageSent.Id);
@@ -32,6 +41,7 @@ internal class NetworkMetrics : INetworkMetrics
         public NetworkMetrics()
         {
             Dispatcher = new MetricDispatcherBuilder()
+                .WithCounters(m_TransportBytesSent, m_TransportBytesReceived)
                 .WithMetricEvents(m_NamedMessageSentEvent, m_NamedMessageReceivedEvent)
                 .WithMetricEvents(m_UnnamedMessageSentEvent, m_UnnamedMessageReceivedEvent)
                 .WithMetricEvents(m_NetworkVariableDeltaSentEvent, m_NetworkVariableDeltaReceivedEvent)
@@ -48,6 +58,16 @@ public NetworkMetrics()
 
         internal IMetricDispatcher Dispatcher { get; }
 
+        public void TrackTransportBytesSent(long bytesCount)
+        {
+            m_TransportBytesSent.Increment(bytesCount);
+        }
+
+        public void TrackTransportBytesReceived(long bytesCount)
+        {
+            m_TransportBytesReceived.Increment(bytesCount);
+        }
+
         public void TrackNetworkObject(NetworkObject networkObject)
         {
             if (!m_NetworkGameObjects.ContainsKey(networkObject.NetworkObjectId))

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

@@ -4,6 +4,14 @@ namespace Unity.Netcode
 {
     internal class NullNetworkMetrics : INetworkMetrics
     {
+        public void TrackTransportBytesSent(long bytesCount)
+        {
+        }
+
+        public void TrackTransportBytesReceived(long bytesCount)
+        {
+        }
+
         public void TrackNetworkObject(NetworkObject networkObject)
         {
         }

com.unity.netcode.gameobjects/Tests/Editor/Metrics/NetworkMetricsRegistrationTests.cs

@@ -27,7 +27,7 @@ public void ValidateThatAllMetricTypesAreRegistered(Type metricType)
             Assert.NotNull(collection);
 
             Assert.That(
-                collection.Metrics,
+                collection.Metrics.OfType<IEventMetric>(),
                 Has.Exactly(2).Matches<IEventMetric>(
                     eventMetric =>
                     {

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

@@ -0,0 +1,89 @@
+#if MULTIPLAYER_TOOLS
+using System;
+using System.Collections;
+using System.IO;
+using NUnit.Framework;
+using Unity.Multiplayer.Tools.MetricTypes;
+using Unity.Multiplayer.Tools.NetStats;
+using Unity.Netcode.RuntimeTests.Metrics.Utlity;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.RuntimeTests.Metrics
+{
+    public class TransportBytesMetricsTests : SingleClientMetricTestBase
+    {
+        const long MessageOverhead = 9;
+
+        [UnityTest]
+        public IEnumerator TrackTotalNumberOfBytesSent()
+        {
+            var messageName = Guid.NewGuid().ToString();
+            using var memoryStream = new MemoryStream();
+            using var binaryWriter = new BinaryWriter(memoryStream);
+            binaryWriter.Write(messageName);
+
+            var observer = new TotalBytesObserver(ServerMetrics.Dispatcher, NetworkMetricTypes.TotalBytesSent);
+
+            Server.CustomMessagingManager.SendNamedMessage(messageName, Client.LocalClientId, memoryStream);
+
+            var nbFrames = 0;
+            while (!observer.Found || nbFrames < 10)
+            {
+                yield return null;
+                nbFrames++;
+            }
+
+            Assert.True(observer.Found);
+            Assert.AreEqual(messageName.Length + MessageOverhead, observer.Value);
+        }
+
+        [UnityTest]
+        public IEnumerator TrackTotalNumberOfBytesReceived()
+        {
+            var messageName = Guid.NewGuid().ToString();
+            using var memoryStream = new MemoryStream();
+            using var binaryWriter = new BinaryWriter(memoryStream);
+            binaryWriter.Write(messageName);
+
+            var observer = new TotalBytesObserver(ClientMetrics.Dispatcher, NetworkMetricTypes.TotalBytesReceived);
+
+            Server.CustomMessagingManager.SendNamedMessage(messageName, Client.LocalClientId, memoryStream);
+
+            var nbFrames = 0;
+            while (!observer.Found || nbFrames < 10)
+            {
+                yield return null;
+                nbFrames++;
+            }
+
+            Assert.True(observer.Found);
+            Assert.AreEqual(messageName.Length + MessageOverhead, observer.Value);
+        }
+
+        private class TotalBytesObserver : IMetricObserver
+        {
+            private readonly DirectionalMetricInfo m_MetricInfo;
+
+            public TotalBytesObserver(IMetricDispatcher dispatcher, DirectionalMetricInfo metricInfo)
+            {
+                m_MetricInfo = metricInfo;
+
+                dispatcher.RegisterObserver(this);
+            }
+
+            public bool Found { get; private set; }
+
+            public long Value { get; private set; }
+
+            public void Observe(MetricCollection collection)
+            {
+                if (collection.TryGetCounter(m_MetricInfo.Id, out var counter) && counter.Value > 0)
+                {
+                    Found = true;
+                    Value = counter.Value;
+                }
+            }
+        }
+    }
+}
+#endif

testproject-tools-integration/Packages/manifest.json

@@ -3,7 +3,7 @@
   "dependencies": {
     "com.unity.ide.rider": "3.0.7",
     "com.unity.netcode.gameobjects": "file:../../com.unity.netcode.gameobjects",
-    "com.unity.multiplayer.tools": "0.0.1-preview.6",
+    "com.unity.multiplayer.tools": "0.0.1-preview.7",
     "com.unity.multiplayer.transport.utp": "file:../../com.unity.multiplayer.transport.utp",
     "com.unity.test-framework": "1.1.26",
     "com.unity.modules.ai": "1.0.0",