Kubediag (#1995)

* Rename logging template placeholders
asynkron · May 11, 2023 · 9200268 · 9200268
1 parent 17781b8
commit 9200268
Show file tree

Hide file tree

Showing 15 changed files with 40 additions and 34 deletions.
diff --git a/benchmarks/KubernetesDiagnostics/Program.cs b/benchmarks/KubernetesDiagnostics/Program.cs
@@ -86,6 +86,12 @@ public static async Task Main()
         await system
             .Cluster()
             .StartMemberAsync();
+
+        system.Shutdown.Register(() =>
+        {
+            Console.WriteLine("Shutting down...");
+            Environment.Exit(0);
+        });
 
         var props = Props.FromFunc(ctx => Task.CompletedTask);
         system.Root.SpawnNamed(props, "dummy");

diff --git a/src/Proto.Actor/Context/ActorLoggingContext.cs b/src/Proto.Actor/Context/ActorLoggingContext.cs
@@ -47,7 +47,7 @@ public override async Task Receive(MessageEnvelope envelope)
 
         if (logLevel != LogLevel.None && _logger.IsEnabled(logLevel))
         {
-            _logger.Log(logLevel, "Actor {Self} {ActorType} received message {MessageType}:{Message} from {Sender}",
+            _logger.Log(logLevel, "Actor {Self} {ActorType} received message {MessageType}:{MessagePayload} from {Sender}",
                 Self, ActorType, message.GetMessageTypeName(),
                 message,
                 SenderOrNone(envelope)
@@ -61,7 +61,7 @@ public override async Task Receive(MessageEnvelope envelope)
             if (logLevel != LogLevel.None && _logger.IsEnabled(logLevel))
             {
                 _logger.Log(logLevel,
-                    "Actor {Self} {ActorType} completed message {MessageType}:{Message} from {Sender}", Self, ActorType,
+                    "Actor {Self} {ActorType} completed message {MessageType}:{MessagePayload} from {Sender}", Self, ActorType,
                     message.GetMessageTypeName(),
                     message,
                     SenderOrNone(envelope)
@@ -73,7 +73,7 @@ public override async Task Receive(MessageEnvelope envelope)
             if (_exceptionLogLevel != LogLevel.None && _logger.IsEnabled(_exceptionLogLevel))
             {
                 _logger.Log(_exceptionLogLevel, x,
-                    "Actor {Self} {ActorType} failed during message {MessageType}:{Message} from {Sender}", Self,
+                    "Actor {Self} {ActorType} failed during message {MessageType}:{MessagePayload} from {Sender}", Self,
                     ActorType,
                     message.GetMessageTypeName(), message,
                     SenderOrNone(envelope)
@@ -110,7 +110,7 @@ public override async Task<T> RequestAsync<T>(PID target, object message, Cancel
     {
         if (_logLevel != LogLevel.None && _logger.IsEnabled(_logLevel))
         {
-            _logger.Log(_logLevel, "Actor {Self} {ActorType} Sending RequestAsync {MessageType}:{Message} to {Target}",
+            _logger.Log(_logLevel, "Actor {Self} {ActorType} Sending RequestAsync {MessageType}:{MessagePayload} to {Target}",
                 Self, ActorType,
                 message.GetMessageTypeName(), message, target
             );
@@ -123,7 +123,7 @@ public override async Task<T> RequestAsync<T>(PID target, object message, Cancel
             if (_logLevel != LogLevel.None && _logger.IsEnabled(_logLevel))
             {
                 _logger.Log(_logLevel,
-                    "Actor {Self} {ActorType} Got response {Response} to {MessageType}:{Message} from {Target}", Self,
+                    "Actor {Self} {ActorType} Got response {Response} to {MessageType}:{MessagePayload} from {Target}", Self,
                     ActorType,
                     response, message.GetMessageTypeName(), message, target
                 );
@@ -136,7 +136,7 @@ public override async Task<T> RequestAsync<T>(PID target, object message, Cancel
             if (_exceptionLogLevel != LogLevel.None && _logger.IsEnabled(_exceptionLogLevel))
             {
                 _logger.Log(_exceptionLogLevel, x,
-                    "Actor {Self} {ActorType} Got exception waiting for RequestAsync response of {MessageType}:{Message} from {Target}",
+                    "Actor {Self} {ActorType} Got exception waiting for RequestAsync response of {MessageType}:{MessagePayload} from {Target}",
                     Self,
                     ActorType,
                     message.GetMessageTypeName(), message, target
@@ -195,7 +195,7 @@ public override void Respond(object message)
 
         if (logLevel != LogLevel.None && _logger.IsEnabled(logLevel))
         {
-            _logger.Log(logLevel, "Actor {Self} {ActorType} responded with {MessageType}:{Message} to {Sender}", Self,
+            _logger.Log(logLevel, "Actor {Self} {ActorType} responded with {MessageType}:{MessagePayload} to {Sender}", Self,
                 ActorType,
                 message.GetMessageTypeName(), message, Sender
             );
@@ -218,7 +218,7 @@ public override void Request(PID target, object message, PID? sender)
     {
         if (_logLevel != LogLevel.None && _logger.IsEnabled(_logLevel))
         {
-            _logger.Log(_logLevel, "Actor {Self} {ActorType} Sending Request {MessageType}:{Message} to {Target}",
+            _logger.Log(_logLevel, "Actor {Self} {ActorType} Sending Request {MessageType}:{MessagePayload} to {Target}",
                 Self, ActorType,
                 message.GetMessageTypeName(), message, target
             );
@@ -231,7 +231,7 @@ public override void Send(PID target, object message)
     {
         if (_logLevel != LogLevel.None && _logger.IsEnabled(_logLevel))
         {
-            _logger.Log(_logLevel, "Actor {Self} {ActorType} Sending {MessageType}:{Message} to {Target}", Self,
+            _logger.Log(_logLevel, "Actor {Self} {ActorType} Sending {MessageType}:{MessagePayload} to {Target}", Self,
                 ActorType,
                 message.GetMessageTypeName(), message, target
             );

diff --git a/src/Proto.Actor/Context/DeadlineContextDecorator.cs b/src/Proto.Actor/Context/DeadlineContextDecorator.cs
@@ -61,7 +61,7 @@ public override async Task Receive(MessageEnvelope envelope)
 
         if (!ok)
         {
-            _logger.LogWarning("Actor {Self} deadline {Deadline}, exceeded on message {Message}", _context.Self,
+            _logger.LogWarning("Actor {Self} deadline {Deadline}, exceeded on message {MessagePayload}", _context.Self,
                 _deadline, envelope.Message);
 
             // keep waiting, we cannot just ignore and continue as an async task might still be running and updating state of the actor

diff --git a/src/Proto.Actor/Context/RootLoggingContext.cs b/src/Proto.Actor/Context/RootLoggingContext.cs
@@ -33,7 +33,7 @@ public override void Send(PID target, object message)
 
         if (logLevel != LogLevel.None && _logger.IsEnabled(logLevel))
         {
-            _logger.Log(logLevel, "RootContext Sending {MessageType}:{Message} to {Target}", message.GetMessageTypeName(), message,
+            _logger.Log(logLevel, "RootContext Sending {MessageType}:{MessagePayload} to {Target}", message.GetMessageTypeName(), message,
                 target);
         }
 
@@ -59,7 +59,7 @@ public override void Request(PID target, object message, PID? sender)
 
         if (logLevel != LogLevel.None && _logger.IsEnabled(logLevel))
         {
-            _logger.Log(logLevel, "Sending Request {MessageType}:{Message} to {Target}", message.GetMessageTypeName(),
+            _logger.Log(logLevel, "Sending Request {MessageType}:{MessagePayload} to {Target}", message.GetMessageTypeName(),
                 message, target);
         }
 
@@ -137,7 +137,7 @@ public override void Request(PID target, object message)
 
         if (logLevel != LogLevel.None && _logger.IsEnabled(logLevel))
         {
-            _logger.Log(logLevel, "RootContext Sending Request {MessageType}:{Message} to {Target}", message.GetMessageTypeName(),
+            _logger.Log(logLevel, "RootContext Sending Request {MessageType}:{MessagePayload} to {Target}", message.GetMessageTypeName(),
                 message, target);
         }
 
@@ -148,7 +148,7 @@ public override async Task<T> RequestAsync<T>(PID target, object message, Cancel
     {
         if (_logLevel != LogLevel.None && _logger.IsEnabled(_logLevel))
         {
-            _logger.Log(_logLevel, "RootContext Sending RequestAsync {MessageType}:{Message} to {Target}",
+            _logger.Log(_logLevel, "RootContext Sending RequestAsync {MessageType}:{MessagePayload} to {Target}",
                 message.GetMessageTypeName(), message, target
             );
         }
@@ -160,7 +160,7 @@ public override async Task<T> RequestAsync<T>(PID target, object message, Cancel
             if (_logLevel != LogLevel.None && _logger.IsEnabled(_logLevel))
             {
                 _logger.Log(_logLevel,
-                    "RootContext Got response {Response} to {MessageType}:{Message} from {Target}",
+                    "RootContext Got response {Response} to {MessageType}:{MessagePayload} from {Target}",
                     response, message.GetMessageTypeName(), message, target
                 );
             }
@@ -172,7 +172,7 @@ public override async Task<T> RequestAsync<T>(PID target, object message, Cancel
             if (_exceptionLogLevel != LogLevel.None && _logger.IsEnabled(_exceptionLogLevel))
             {
                 _logger.Log(_exceptionLogLevel, x,
-                    "RootContext Got exception waiting for RequestAsync response of {MessageType}:{Message} from {Target}",
+                    "RootContext Got exception waiting for RequestAsync response of {MessageType}:{MessagePayload} from {Target}",
                     message.GetMessageTypeName(), message, target
                 );
             }

diff --git a/src/Proto.Actor/Diagnostics/DiagnosticsStore.cs b/src/Proto.Actor/Diagnostics/DiagnosticsStore.cs
@@ -51,7 +51,7 @@ public void RegisterEvent(string module, string message)
         var entry = new DiagnosticsEntry(module, message, null);
         if (_entries.TryAdd(entry))
         {
-            _logger.Log(_logLevel, "[Diagnostics] {Module}: {Message}", module, message);
+            _logger.Log(_logLevel, "[Diagnostics] {Module}: {MessagePayload}", module, message);
         }
     }
 

diff --git a/src/Proto.Actor/EventStream/EventStream.cs b/src/Proto.Actor/EventStream/EventStream.cs
@@ -50,7 +50,7 @@ internal EventStream(ActorSystem system)
                     dl.Message is not IIgnoreDeadLetterLogging)
                 {
                     _logger.LogInformation(
-                        "[DeadLetter] could not deliver '{MessageType}:{Message}' to '{Target}' from '{Sender}'",
+                        "[DeadLetter] could not deliver '{MessageType}:{MessagePayload}' to '{Target}' from '{Sender}'",
                         dl.Message.GetMessageTypeName(),
                         dl.Message,
                         dl.Pid,

diff --git a/src/Proto.Cluster/Member/MemberList.cs b/src/Proto.Cluster/Member/MemberList.cs
@@ -361,7 +361,7 @@ public void BroadcastEvent(object message, bool includeSelf = true)
             catch (Exception x)
             {
                 x.CheckFailFast();
-                Logger.LogError(x, "[MemberList] Failed to broadcast {Message} to {Pid}", message, pid);
+                Logger.LogError(x, "[MemberList] Failed to broadcast {MessagePayload} to {Pid}", message, pid);
             }
         }
     }

diff --git a/src/Proto.Remote/Endpoints/Endpoint.cs b/src/Proto.Remote/Endpoints/Endpoint.cs
@@ -100,7 +100,7 @@ public void SendMessage(PID target, object msg)
 
         if (_logger.IsEnabled(LogLevel.Trace))
         {
-            _logger.LogTrace("[{SystemAddress}] Sending message {MessageType} {Message} to {Target} from {Sender}",
+            _logger.LogTrace("[{SystemAddress}] Sending message {MessageType} {MessagePayload} to {Target} from {Sender}",
                 System.Address,
                 message.GetMessageTypeName(), message, target, sender
             );
@@ -115,7 +115,7 @@ public void SendMessage(PID target, object msg)
 
         if (CancellationToken.IsCancellationRequested || !_remoteDelivers.Writer.TryWrite(env))
         {
-            _logger.LogWarning("[{SystemAddress}] Dropping message {MessageType} {Message} to {Target} from {Sender}",
+            _logger.LogWarning("[{SystemAddress}] Dropping message {MessageType} {MessagePayload} to {Target} from {Sender}",
                 System.Address,
                 message.GetMessageTypeName(), message, target, sender
             );
@@ -249,7 +249,7 @@ private int DropMessagesInBatch(RemoteMessage remoteMessage)
                         message = RemoteConfig.Serialization.Deserialize(typeName, envelope.MessageData,
                             envelope.SerializerId);
 
-                        // _logger.LogDebug("Received (Type) {Message}", message.GetType(), message);
+                        // _logger.LogDebug("Received (Type) {MessagePayload}", message.GetType(), message);
 
                         //translate from on-the-wire representation to in-process representation
                         //this only applies to root level messages, and never on nested child messages
@@ -468,14 +468,14 @@ private MessageBatch CreateBatch(IReadOnlyCollection<RemoteDeliver> m)
             catch (CodedOutputStream.OutOfSpaceException oom)
             {
                 System.Diagnostics.RegisterEvent("Remote", $"Message is too large {message.GetMessageTypeName()}");
-                _logger.LogError(oom, "Message is too large {Message}", message.GetMessageTypeName());
+                _logger.LogError(oom, "Message is too large {MessagePayload}", message.GetMessageTypeName());
 
                 throw;
             }
             catch (Exception x)
             {
                 System.Diagnostics.RegisterEvent("Remote", $"Missing serializer for {message.GetMessageTypeName()}");
-                _logger.LogError(x, "Serialization failed for message {Message}", message.GetMessageTypeName());
+                _logger.LogError(x, "Serialization failed for message {MessagePayload}", message.GetMessageTypeName());
 
                 throw;
             }

diff --git a/src/Proto.Remote/Endpoints/RemoteMessageHandler.cs b/src/Proto.Remote/Endpoints/RemoteMessageHandler.cs
@@ -142,7 +142,7 @@ public void HandleRemoteMessage(RemoteMessage currentMessage, string remoteAddre
                             if (_logger.IsEnabled(LogLevel.Trace))
                             {
                                 _logger.LogTrace(
-                                    "[{SystemAddress}] Received message {MessageType} {Message} for {Target}",
+                                    "[{SystemAddress}] Received message {MessageType} {MessagePayload} for {Target}",
                                     _system.Address,
                                     msg.GetType().Name, msg, target
                                 );
@@ -159,7 +159,7 @@ public void HandleRemoteMessage(RemoteMessage currentMessage, string remoteAddre
                             if (_logger.IsEnabled(LogLevel.Trace))
                             {
                                 _logger.LogTrace(
-                                    "[{SystemAddress}] Received system message {MessageType} {Message} for {Target}",
+                                    "[{SystemAddress}] Received system message {MessageType} {MessagePayload} for {Target}",
                                     _system.Address,
                                     sys.GetType().Name, sys, target
                                 );
@@ -190,7 +190,7 @@ public void HandleRemoteMessage(RemoteMessage currentMessage, string remoteAddre
                             if (_logger.IsEnabled(LogLevel.Trace))
                             {
                                 _logger.LogTrace(
-                                    "[{SystemAddress}] Received user message {MessageType} {Message} for {Target} from {Sender}",
+                                    "[{SystemAddress}] Received user message {MessageType} {MessagePayload} for {Target} from {Sender}",
                                     _system.Address, message.GetMessageTypeName(), message, target, sender
                                 );
                             }

diff --git a/src/Proto.Remote/Endpoints/ServerConnector.cs b/src/Proto.Remote/Endpoints/ServerConnector.cs
@@ -318,7 +318,7 @@ private Task StartReader(AsyncDuplexStreamingCall<RemoteMessage, RemoteMessage>
                             if (_connectorType == Type.ServerSide)
                             {
                                 _logger.LogWarning(
-                                    "[ServerConnector][{SystemAddress}] Received {Message} from {Addres}",
+                                    "[ServerConnector][{SystemAddress}] Received {MessagePayload} from {Addres}",
                                     _system.Address, currentMessage, _address);
                             }
                             else

diff --git a/src/Proto.Remote/GrpcNet/GrpcNetClientRemote.cs b/src/Proto.Remote/GrpcNet/GrpcNetClientRemote.cs
@@ -69,7 +69,7 @@ public Task ShutdownAsync(bool graceful = true)
         catch (Exception ex)
         {
             _logger.LogError(
-                ex, "Proto.Actor client {Id} stopped with error: {Message}",
+                ex, "Proto.Actor client {Id} stopped with error: {MessagePayload}",
                 System.Id, ex.Message
             );
         }

diff --git a/src/Proto.Remote/GrpcNet/GrpcNetRemote.cs b/src/Proto.Remote/GrpcNet/GrpcNetRemote.cs
@@ -174,7 +174,7 @@ public async Task ShutdownAsync(bool graceful = true)
         catch (Exception ex)
         {
             _logger.LogError(
-                ex, "Proto.Actor server stopped on {Address} with error: {Message}",
+                ex, "Proto.Actor server stopped on {Address} with error: {MessagePayload}",
                 System.Address, ex.Message
             );
         }

diff --git a/src/Proto.Remote/GrpcNet/HostedGrpcNetRemote.cs b/src/Proto.Remote/GrpcNet/HostedGrpcNetRemote.cs
@@ -87,7 +87,7 @@ public Task ShutdownAsync(bool graceful = true)
             catch (Exception ex)
             {
                 _logger.LogError(
-                    ex, "Proto.Actor server stopped on {Address} with error: {Message}",
+                    ex, "Proto.Actor server stopped on {Address} with error: {MessagePayload}",
                     System.Address, ex.Message
                 );
 

diff --git a/src/Proto.Remote/Serialization/ForcedSerializationSenderMiddleware.cs b/src/Proto.Remote/Serialization/ForcedSerializationSenderMiddleware.cs
@@ -78,15 +78,15 @@ public static Func<Sender, Sender> Create(Func<Proto.MessageEnvelope, bool>? sho
                 }
                 catch (CodedOutputStream.OutOfSpaceException oom)
                 {
-                    Logger.LogError(oom, "Message is too large for serialization {Message}", message?.GetType().Name);
+                    Logger.LogError(oom, "Message is too large for serialization {MessagePayload}", message?.GetType().Name);
 
                     throw;
                 }
                 catch (Exception ex)
                 {
                     ex.CheckFailFast();
 
-                    Logger.LogError(ex, "Forced serialization -> deserialization failed for message {Message}",
+                    Logger.LogError(ex, "Forced serialization -> deserialization failed for message {MessagePayload}",
                         message?.GetType().Name);
 
                     throw;

diff --git a/tests/Proto.Cluster.Tests/ClusterFixture.cs b/tests/Proto.Cluster.Tests/ClusterFixture.cs
@@ -294,7 +294,7 @@ protected virtual async Task<Cluster> SpawnClusterMember(Func<ClusterConfig, Clu
 
         system.EventStream.Subscribe<object>(e =>
             {
-                logger?.LogDebug("EventStream {MessageType}:{Message}", e.GetType().Name, e);
+                logger?.LogDebug("EventStream {MessageType}:{MessagePayload}", e.GetType().Name, e);
             }
         );