Use [LoggerMessage] in Orleans.Core (#9352)

Author: Meir017

src/Orleans.Core/Configuration/OptionLogger/IOptionsLogger.cs

@@ -8,7 +8,7 @@
 using Microsoft.Extensions.Logging;
 
 namespace Orleans
-{ 
+{
     /// <summary>
     /// Logger for options on the client.
     /// </summary>
@@ -50,7 +50,7 @@ public Task OnStart(CancellationToken token)
     /// <summary>
     /// Base class for client and silo default options loggers.
     /// </summary>
-    public abstract class OptionsLogger 
+    public abstract partial class OptionsLogger
     {
         private readonly ILogger logger;
         private readonly IServiceProvider services;
@@ -98,18 +98,30 @@ public void LogOption(IOptionFormatter formatter)
         {
             try
             {
-                var stringBuiler = new StringBuilder();
-                stringBuiler.AppendLine($"Configuration {formatter.Name}: ");
+                var stringBuilder = new StringBuilder();
                 foreach (var setting in formatter.Format())
                 {
-                    stringBuiler.AppendLine($"{setting}");
+                    stringBuilder.AppendLine($"{setting}");
                 }
-                this.logger.LogInformation(stringBuiler.ToString());
-            } catch(Exception ex)
+                LogInformationOptions(logger, formatter.Name, stringBuilder.ToString());
+            }
+            catch(Exception ex)
             {
-                this.logger.LogError(ex, $"An error occurred while logging options {formatter.Name}", formatter.Name);
+                LogErrorOptions(logger, ex, formatter.Name);
                 throw;
             }
         }
+
+        [LoggerMessage(
+            Level = LogLevel.Information,
+            Message = "Configuration {Name}:\n{Options}"
+        )]
+        private static partial void LogInformationOptions(ILogger logger, string name, string options);
+
+        [LoggerMessage(
+            Level = LogLevel.Error,
+            Message = "An error occurred while logging '{Name}' options."
+        )]
+        private static partial void LogErrorOptions(ILogger logger, Exception exception, string name);
     }
 }

src/Orleans.Core/Core/ClusterClient.cs

@@ -15,7 +15,7 @@ namespace Orleans
     /// <summary>
     /// Client for communicating with clusters of Orleans silos.
     /// </summary>
-    internal class ClusterClient : IInternalClusterClient, IHostedService
+    internal partial class ClusterClient : IInternalClusterClient, IHostedService
     {
         private readonly OutsideRuntimeClient _runtimeClient;
         private readonly ILogger<ClusterClient> _logger;
@@ -69,14 +69,14 @@ public async Task StopAsync(CancellationToken cancellationToken)
         {
             try
             {
-                _logger.LogInformation("Client shutting down");
+                LogClientShuttingDown(_logger);
 
                 await _clusterClientLifecycle.OnStop(cancellationToken).ConfigureAwait(false);
                 await _runtimeClient.StopAsync(cancellationToken).WaitAsync(cancellationToken);
             }
             finally
             {
-                _logger.LogInformation("Client shutdown completed");
+                LogClientShutdownCompleted(_logger);
             }
         }
 
@@ -152,5 +152,17 @@ public object Cast(IAddressable grain, Type outputGrainInterfaceType)
         /// <inheritdoc />
         public IAddressable GetGrain(GrainId grainId, GrainInterfaceType interfaceType)
             => _runtimeClient.InternalGrainFactory.GetGrain(grainId, interfaceType);
+
+        [LoggerMessage(
+            Level = LogLevel.Information,
+            Message = "Client shutting down."
+        )]
+        private static partial void LogClientShuttingDown(ILogger logger);
+
+        [LoggerMessage(
+            Level = LogLevel.Information,
+            Message = "Client shutdown completed."
+        )]
+        private static partial void LogClientShutdownCompleted(ILogger logger);
     }
 }

src/Orleans.Core/Lifecycle/LifecycleSubject.cs

@@ -21,7 +21,7 @@ namespace Orleans
     /// <item><description>OnStop stops all stages regardless of errors even if canceled.</description></item>
     /// </list>
     /// </remarks>
-    public abstract class LifecycleSubject : ILifecycleSubject
+    public abstract partial class LifecycleSubject : ILifecycleSubject
     {
         private readonly List<OrderedObserver> subscribers = [];
         protected readonly ILogger Logger;
@@ -86,14 +86,7 @@ protected static ImmutableDictionary<int, string> GetStageNames(Type type)
         /// <param name="elapsed">The period of time which elapsed before <see cref="OnStart"/> completed once it was initiated.</param>
         protected virtual void PerfMeasureOnStart(int stage, TimeSpan elapsed)
         {
-            if (this.Logger.IsEnabled(LogLevel.Trace))
-            {
-                this.Logger.LogTrace(
-                    (int)ErrorCode.SiloStartPerfMeasure,
-                    "Starting lifecycle stage '{Stage}' took '{Elapsed}'.",
-                    GetStageName(stage),
-                    elapsed);
-            }
+            LogLifecycleStageStarted(Logger, GetStageName(stage), elapsed);
         }
 
         /// <inheritdoc />
@@ -123,11 +116,7 @@ public virtual async Task OnStart(CancellationToken cancellationToken = default)
             }
             catch (Exception ex) when (ex is not OrleansLifecycleCanceledException)
             {
-                this.Logger.LogError(
-                    (int)ErrorCode.LifecycleStartFailure,
-                    ex,
-                    "Lifecycle start canceled due to errors at stage '{Stage}'.",
-                    _highStage is { } highStage ? GetStageName(highStage) : "Unknown");
+                LogErrorLifecycleStartFailure(Logger, ex, _highStage is { } highStage ? GetStageName(highStage) : "Unknown");
                 throw;
             }
 
@@ -157,14 +146,7 @@ protected virtual void OnStartStageCompleted(int stage) { }
         /// <param name="elapsed">The period of time which elapsed before <see cref="OnStop"/> completed once it was initiated.</param>
         protected virtual void PerfMeasureOnStop(int stage, TimeSpan elapsed)
         {
-            if (this.Logger.IsEnabled(LogLevel.Trace))
-            {
-                this.Logger.LogTrace(
-                    (int)ErrorCode.SiloStartPerfMeasure,
-                    "Stopping lifecycle stage '{Stage}' took '{Elapsed}'.",
-                    GetStageName(stage),
-                    elapsed);
-            }
+            LogLifecycleStageStopped(Logger, GetStageName(stage), elapsed);
         }
 
         /// <inheritdoc />
@@ -181,7 +163,7 @@ public virtual async Task OnStop(CancellationToken cancellationToken = default)
             {
                 if (cancellationToken.IsCancellationRequested && !loggedCancellation)
                 {
-                    this.Logger.LogWarning("Lifecycle stop operations canceled at stage '{Stage}' by request.", GetStageName(observerGroup.Key));
+                    LogWarningLifecycleStopCanceled(Logger, GetStageName(observerGroup.Key));
                     loggedCancellation = true;
                 }
 
@@ -196,11 +178,7 @@ public virtual async Task OnStop(CancellationToken cancellationToken = default)
                 }
                 catch (Exception ex)
                 {
-                    this.Logger.LogWarning(
-                        (int)ErrorCode.LifecycleStopFailure,
-                        ex,
-                        "Stopping lifecycle encountered an error at stage '{Stage}'. Continuing to stop.",
-                        _highStage is { } highStage ? GetStageName(highStage) : "Unknown");
+                    LogWarningLifecycleStopFailure(Logger, ex, _highStage is { } highStage ? GetStageName(highStage) : "Unknown");
                 }
 
                 this.OnStopStageCompleted(stage);
@@ -264,5 +242,39 @@ public OrderedObserver(int stage, ILifecycleObserver observer)
             /// <inheritdoc />
             public void Dispose() => Observer = null;
         }
+
+        [LoggerMessage(
+            EventId = (int)ErrorCode.LifecycleStartFailure,
+            Level = LogLevel.Error,
+            Message = "Lifecycle start canceled due to errors at stage '{Stage}'."
+        )]
+        private static partial void LogErrorLifecycleStartFailure(ILogger logger, Exception ex, string stage);
+
+        [LoggerMessage(
+            EventId = (int)ErrorCode.LifecycleStopFailure,
+            Level = LogLevel.Warning,
+            Message = "Stopping lifecycle encountered an error at stage '{Stage}'. Continuing to stop."
+        )]
+        private static partial void LogWarningLifecycleStopFailure(ILogger logger, Exception ex, string stage);
+
+        [LoggerMessage(
+            Level = LogLevel.Warning,
+            Message = "Lifecycle stop operations canceled at stage '{Stage}' by request."
+        )]
+        private static partial void LogWarningLifecycleStopCanceled(ILogger logger, string stage);
+
+        [LoggerMessage(
+            EventId = (int)ErrorCode.SiloStartPerfMeasure,
+            Level = LogLevel.Trace,
+            Message = "Starting lifecycle stage '{Stage}' took '{Elapsed}'."
+        )]
+        private static partial void LogLifecycleStageStarted(ILogger logger, string stage, TimeSpan elapsed);
+
+        [LoggerMessage(
+            EventId = (int)ErrorCode.SiloStartPerfMeasure,
+            Level = LogLevel.Trace,
+            Message = "Stopping lifecycle stage '{Stage}' took '{Elapsed}'."
+        )]
+        private static partial void LogLifecycleStageStopped(ILogger logger, string stage, TimeSpan elapsed);
     }
 }

src/Orleans.Core/Manifest/ClientClusterManifestProvider.cs

@@ -19,7 +19,7 @@ namespace Orleans.Runtime
     /// <summary>
     /// <see cref="IClusterManifestProvider"/> implementation for external clients.
     /// </summary>
-    internal class ClientClusterManifestProvider : IClusterManifestProvider, IAsyncDisposable, IDisposable
+    internal partial class ClientClusterManifestProvider : IClusterManifestProvider, IAsyncDisposable, IDisposable
     {
         private readonly TaskCompletionSource<bool> _initialized = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
         private readonly ILogger<ClientClusterManifestProvider> _logger;
@@ -90,11 +90,11 @@ public async Task StopAsync(CancellationToken cancellationToken)
             }
             catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
             {
-                _logger.LogInformation("Graceful shutdown of cluster manifest provider was canceled.");
+                LogGracefulShutdownCanceled(_logger);
             }
             catch (Exception exception)
             {
-                _logger.LogError(exception, "Error stopping cluster manifest provider.");
+                LogStoppingClusterManifestProvider(_logger, exception);
             }
         }
 
@@ -173,10 +173,7 @@ private async Task RunAsync()
 
                         _initialized.TrySetResult(true);
 
-                        if (_logger.IsEnabled(LogLevel.Debug))
-                        {
-                            _logger.LogDebug("Refreshed cluster manifest");
-                        }
+                        LogRefreshedClusterManifest(_logger);
 
                         await Task.Delay(_typeManagementOptions.TypeMapRefreshInterval, _shutdownCts.Token);
                     }
@@ -186,7 +183,7 @@ private async Task RunAsync()
                     }
                     catch (Exception exception)
                     {
-                        _logger.LogWarning(exception, "Error trying to get cluster manifest from gateway {Gateway}", gateway);
+                        LogErrorTryingToGetClusterManifest(_logger, exception, gateway);
                         await Task.Delay(StandardExtensions.Min(_typeManagementOptions.TypeMapRefreshInterval, TimeSpan.FromSeconds(5)), _shutdownCts.Token).SuppressThrowing();
 
                         // Reset the gateway so that another will be selected on the next iteration.
@@ -198,10 +195,7 @@ private async Task RunAsync()
             {
                 _initialized.TrySetResult(false);
 
-                if (_logger.IsEnabled(LogLevel.Debug))
-                {
-                    _logger.LogDebug("Stopped refreshing cluster manifest");
-                }
+                LogStoppedRefreshingClusterManifest(_logger);
             }
         }
 
@@ -215,7 +209,7 @@ private async Task RunAsync()
             }
             catch (Exception exception)
             {
-                _logger.LogWarning(exception, "Failed to fetch cluster manifest update from {Provider}.", provider);
+                LogFailedToFetchClusterManifestUpdate(_logger, exception, provider);
 
                 // If the provider does not support the new API, fall back to the old one.
                 var manifest = await provider.GetClusterManifest();
@@ -244,5 +238,41 @@ public void Dispose()
         {
             _shutdownCts.Cancel();
         }
+
+        [LoggerMessage(
+            Level = LogLevel.Information,
+            Message = "Graceful shutdown of cluster manifest provider was canceled."
+        )]
+        private static partial void LogGracefulShutdownCanceled(ILogger logger);
+
+        [LoggerMessage(
+            Level = LogLevel.Error,
+            Message = "Error stopping cluster manifest provider."
+        )]
+        private static partial void LogStoppingClusterManifestProvider(ILogger logger, Exception exception);
+
+        [LoggerMessage(
+            Level = LogLevel.Debug,
+            Message = "Refreshed cluster manifest."
+        )]
+        private static partial void LogRefreshedClusterManifest(ILogger logger);
+
+        [LoggerMessage(
+            Level = LogLevel.Warning,
+            Message = "Error trying to get cluster manifest from gateway '{Gateway}'."
+        )]
+        private static partial void LogErrorTryingToGetClusterManifest(ILogger logger, Exception exception, SiloAddress gateway);
+
+        [LoggerMessage(
+            Level = LogLevel.Debug,
+            Message = "Stopped refreshing cluster manifest."
+        )]
+        private static partial void LogStoppedRefreshingClusterManifest(ILogger logger);
+
+        [LoggerMessage(
+            Level = LogLevel.Warning,
+            Message = "Failed to fetch cluster manifest update from '{Provider}'."
+        )]
+        private static partial void LogFailedToFetchClusterManifestUpdate(ILogger logger, Exception exception, IClusterManifestSystemTarget provider);
     }
 }