Feat: Server logs metrics (#956)

Author: Josie Messa

com.unity.multiplayer.mlapi/Runtime/Logging/NetworkLog.cs

@@ -1,5 +1,4 @@
 using MLAPI.Configuration;
-using MLAPI.Messaging;
 using MLAPI.Serialization.Pooled;
 using MLAPI.Transports;
 using UnityEngine;
@@ -67,6 +66,7 @@ private static void LogServer(string message, LogType logType)
                     writer.WriteStringPacked(message);
 
                     NetworkManager.Singleton.MessageSender.Send(NetworkManager.Singleton.ServerClientId, NetworkConstants.SERVER_LOG, NetworkChannel.Internal, buffer);
+                    NetworkManager.Singleton.NetworkMetrics.TrackServerLogSent(NetworkManager.Singleton.ServerClientId, (uint)logType, (ulong)buffer.Length);
                 }
             }
         }

com.unity.multiplayer.mlapi/Runtime/Messaging/InternalMessageHandler.cs

@@ -380,7 +380,9 @@ public void HandleNetworkLog(ulong clientId, Stream stream)
         {
             using (var reader = PooledNetworkReader.Get(stream))
             {
+                var length = stream.Length;
                 var logType = (NetworkLog.LogType)reader.ReadByte();
+                m_NetworkManager.NetworkMetrics.TrackServerLogReceived(clientId, (uint)logType, (ulong)length);
                 string message = reader.ReadStringPacked();
 
                 switch (logType)

com.unity.multiplayer.mlapi/Runtime/Metrics/INetworkMetrics.cs

@@ -38,6 +38,10 @@ public interface INetworkMetrics
 
         void TrackRpcReceived(ulong senderClientId, ulong networkObjectId, string rpcName, ulong bytesCount);
 
+        void TrackServerLogSent(ulong receiverClientId, uint logType, ulong bytesCount);
+
+        void TrackServerLogReceived(ulong senderClientId, uint logType, ulong bytesCount);
+
         void DispatchFrame();
     }
 }

com.unity.multiplayer.mlapi/Runtime/Metrics/NetworkMetrics.cs

@@ -1,5 +1,4 @@
 #if MULTIPLAYER_TOOLS
-
 using System.Collections.Generic;
 using Unity.Multiplayer.MetricTypes;
 using Unity.Multiplayer.NetStats.Dispatch;
@@ -25,6 +24,8 @@ public class NetworkMetrics : INetworkMetrics
         private readonly EventMetric<ObjectSpawnedEvent> m_ObjectSpawnReceivedEvent = new EventMetric<ObjectSpawnedEvent>(MetricNames.ObjectSpawnedReceived);
         private readonly EventMetric<ObjectDestroyedEvent> m_ObjectDestroySentEvent = new EventMetric<ObjectDestroyedEvent>(MetricNames.ObjectDestroyedSent);
         private readonly EventMetric<ObjectDestroyedEvent> m_ObjectDestroyReceivedEvent = new EventMetric<ObjectDestroyedEvent>(MetricNames.ObjectDestroyedReceived);
+        private readonly EventMetric<ServerLogEvent> m_ServerLogSentEvent = new EventMetric<ServerLogEvent>(MetricNames.ServerLogSent);
+        private readonly EventMetric<ServerLogEvent> m_ServerLogReceivedEvent = new EventMetric<ServerLogEvent>(MetricNames.ServerLogReceived);
 
         readonly EventMetric<RpcEvent> m_RpcSentEvent = new EventMetric<RpcEvent>(MetricNames.RpcSent);
         readonly EventMetric<RpcEvent> m_RpcReceivedEvent = new EventMetric<RpcEvent>(MetricNames.RpcReceived);
@@ -41,6 +42,7 @@ public NetworkMetrics(NetworkManager networkManager)
                 .WithMetricEvents(m_ObjectSpawnSentEvent, m_ObjectSpawnReceivedEvent)
                 .WithMetricEvents(m_ObjectDestroySentEvent, m_ObjectDestroyReceivedEvent)
                 .WithMetricEvents(m_RpcSentEvent, m_RpcReceivedEvent)
+                .WithMetricEvents(m_ServerLogSentEvent, m_ServerLogReceivedEvent)
                 .Build();
 
             Dispatcher.RegisterObserver(MLAPIObserver.Observer);
@@ -161,6 +163,16 @@ public void TrackRpcReceived(ulong senderClientId, ulong networkObjectId, string
             m_RpcReceivedEvent.Mark(new RpcEvent(new ConnectionInfo(senderClientId), networkObjectIdentifier, rpcName, bytesCount));
         }
 
+        public void TrackServerLogSent(ulong receiverClientId, uint logType, ulong bytesCount)
+        {
+            m_ServerLogSentEvent.Mark(new ServerLogEvent(new ConnectionInfo(receiverClientId), (LogLevel)logType, bytesCount));
+        }
+
+        public void TrackServerLogReceived(ulong senderClientId, uint logType, ulong bytesCount)
+        {
+            m_ServerLogReceivedEvent.Mark(new ServerLogEvent(new ConnectionInfo(senderClientId), (LogLevel)logType, bytesCount));
+        }
+
         public void DispatchFrame()
         {
             Dispatcher.Dispatch();
@@ -177,5 +189,4 @@ public class MLAPIObserver
         public static IMetricObserver Observer { get; } = MetricObserverFactory.Construct();
     }
 }
-
 #endif

com.unity.multiplayer.mlapi/Runtime/Metrics/NullNetworkMetrics.cs

@@ -72,6 +72,14 @@ public void TrackRpcReceived(ulong senderClientId, ulong networkObjectId, string
         {
         }
 
+        public void TrackServerLogSent(ulong receiverClientId, uint logType, ulong bytesCount)
+        {
+        }
+
+        public void TrackServerLogReceived(ulong senderClientId, uint logType, ulong bytesCount)
+        {
+        }
+
         public void DispatchFrame()
         {
         }

com.unity.multiplayer.mlapi/Tests/Runtime/Metrics/ServerLogs.meta

@@ -0,0 +1,89 @@
+using System.Collections;
+using System.Linq;
+using MLAPI.Logging;
+using MLAPI.Metrics;
+using NUnit.Framework;
+using Unity.Multiplayer.NetworkProfiler;
+using Unity.Multiplayer.NetworkProfiler.Models;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace MLAPI.RuntimeTests.Metrics.ServerLogs
+{
+    public class ServerLogsMetricTests
+    {
+        NetworkManager m_Server;
+        NetworkManager m_Client;
+        NetworkMetrics m_ClientMetrics;
+        NetworkMetrics m_ServerMetrics;
+
+
+        [UnitySetUp]
+        public IEnumerator SetUp()
+        {
+            if (!MultiInstanceHelpers.Create(1, out m_Server, out var clients))
+            {
+                Debug.LogError("Failed to create instances");
+                Assert.Fail("Failed to create instances");
+            }
+
+            var playerPrefab = new GameObject("Player");
+            var networkObject = playerPrefab.AddComponent<NetworkObject>();
+
+            MultiInstanceHelpers.MakeNetworkedObjectTestPrefab(networkObject);
+
+            m_Server.NetworkConfig.PlayerPrefab = playerPrefab;
+
+            foreach (var client in clients)
+            {
+                client.NetworkConfig.PlayerPrefab = playerPrefab;
+            }
+
+            if (!MultiInstanceHelpers.Start(true, m_Server, clients))
+            {
+                Debug.LogError("Failed to start instances");
+                Assert.Fail("Failed to start instances");
+            }
+
+            yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.WaitForClientsConnected(clients));
+            yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.WaitForClientConnectedToServer(m_Server));
+
+            m_Client = clients.First();
+            m_ClientMetrics = m_Client.NetworkMetrics as NetworkMetrics;
+            m_ServerMetrics = m_Server.NetworkMetrics as NetworkMetrics;
+        }
+
+        [UnityTearDown]
+        public IEnumerator TearDown()
+        {
+            MultiInstanceHelpers.Destroy();
+
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator TrackServerLogSentAndReceivedMetric()
+        {
+            var waitForSentMetric = new WaitForMetricValues<ServerLogEvent>(m_ClientMetrics.Dispatcher, MetricNames.ServerLogSent);
+            var waitForReceivedMetric = new WaitForMetricValues<ServerLogEvent>(m_ClientMetrics.Dispatcher, MetricNames.ServerLogReceived);
+            NetworkLog.LogWarningServer("log message");
+
+            yield return waitForSentMetric.WaitForAFewFrames();
+            yield return waitForReceivedMetric.WaitForAFewFrames();
+
+            var sentMetrics = waitForSentMetric.EnsureMetricValuesHaveBeenFound();
+            Assert.AreEqual(1, sentMetrics.Count);
+
+            var receivedMetrics = waitForReceivedMetric.EnsureMetricValuesHaveBeenFound();
+            Assert.AreEqual(1, receivedMetrics.Count);
+
+            var sentMetric = sentMetrics.First();
+            Assert.AreEqual(m_Server.LocalClientId, sentMetric.Connection.Id);
+            Assert.AreEqual((uint)NetworkLog.LogType.Warning, (uint)sentMetric.LogLevel);
+
+            var receivedMetric = receivedMetrics.First();
+            Assert.AreEqual(m_Client.LocalClientId, receivedMetric.Connection.Id);
+            Assert.AreEqual((uint)NetworkLog.LogType.Warning, (uint)receivedMetric.LogLevel);
+        }
+    }
+}