chore(Orleans.Runtime): Use LoggerMessageGenerator for core logging messages

src/Orleans.Runtime/Cancellation/CancellationSourcesExtension.cs

@@ -12,7 +12,7 @@ namespace Orleans.Runtime
     /// Contains list of cancellation token source corresponding to the tokens
     /// passed to the related grain activation.
     /// </summary>
-    internal class CancellationSourcesExtension : ICancellationSourcesExtension, IDisposable
+    internal partial class CancellationSourcesExtension : ICancellationSourcesExtension, IDisposable
     {
         private readonly ConcurrentDictionary<Guid, Entry> _cancellationTokens = new ConcurrentDictionary<Guid, Entry>();
         private readonly ILogger _logger;
@@ -39,7 +39,7 @@ public Task CancelRemoteToken(Guid tokenId)
         {
             if (!_cancellationTokens.TryGetValue(tokenId, out var entry))
             {
-                _logger.LogWarning((int)ErrorCode.CancellationTokenCancelFailed, "Received a cancel call for token with id {TokenId}, but the token was not found", tokenId);
+                LogCancellationFailed(tokenId);
 
                 // Record the cancellation anyway, in case the call which would have registered the cancellation is still pending.
                 this.RecordCancellationToken(tokenId, isCancellationRequested: true);
@@ -132,5 +132,12 @@ public bool IsExpired(TimeSpan expiry, long nowTimestamp)
                 return untouchedTime >= expiry;
             }
         }
+
+        [LoggerMessage(
+            EventId = (int)ErrorCode.CancellationTokenCancelFailed,
+            Level = LogLevel.Warning,
+            Message = "Received a cancel call for token with id '{TokenId}', but the token was not found."
+        )]
+        private partial void LogCancellationFailed(Guid tokenId);
     }
 }

src/Orleans.Runtime/Catalog/ActivationCollector.cs

@@ -14,7 +14,7 @@ namespace Orleans.Runtime
     /// <summary>
     /// Identifies activations that have been idle long enough to be deactivated.
     /// </summary>
-    internal class ActivationCollector : IActivationWorkingSetObserver, ILifecycleParticipant<ISiloLifecycle>, IDisposable
+    internal partial class ActivationCollector : IActivationWorkingSetObserver, ILifecycleParticipant<ISiloLifecycle>, IDisposable
     {
         private readonly TimeSpan quantum;
         private readonly TimeSpan shortestAgeLimit;
@@ -441,7 +441,7 @@ private async Task RunActivationCollectionLoop()
                 }
                 catch (Exception exception)
                 {
-                    this.logger.LogError(exception, "Error while collecting activations.");
+                    LogErrorWhileCollectingActivations(exception);
                 }
             }
         }
@@ -452,16 +452,7 @@ private async Task CollectActivationsImpl(bool scanStale, TimeSpan ageLimit, Can
             var number = Interlocked.Increment(ref collectionNumber);
             long memBefore = GC.GetTotalMemory(false) / (1024 * 1024);
 
-            if (logger.IsEnabled(LogLevel.Debug))
-            {
-                logger.LogDebug(
-                    (int)ErrorCode.Catalog_BeforeCollection,
-                    "Before collection #{CollectionNumber}: memory: {MemoryBefore}MB, #activations: {ActivationCount}, collector: {CollectorStatus}",
-                    number,
-                    memBefore,
-                    _activationCount,
-                    ToString());
-            }
+            LogBeforeCollection(number, memBefore, _activationCount, this);
 
             List<ICollectibleGrainContext> list = scanStale ? ScanStale() : ScanAll(ageLimit);
             CatalogInstruments.ActivationCollections.Add(1);
@@ -474,23 +465,12 @@ private async Task CollectActivationsImpl(bool scanStale, TimeSpan ageLimit, Can
             long memAfter = GC.GetTotalMemory(false) / (1024 * 1024);
             watch.Stop();
 
-            if (logger.IsEnabled(LogLevel.Debug))
-            {
-                logger.LogDebug(
-                    (int)ErrorCode.Catalog_AfterCollection,
-                    "After collection #{CollectionNumber} memory: {MemoryAfter}MB, #activations: {ActivationCount}, collected {CollectedCount} activations, collector: {CollectorStatus}, collection time: {CollectionTime}",
-                    number,
-                    memAfter,
-                    _activationCount,
-                    list?.Count ?? 0,
-                    ToString(),
-                    watch.Elapsed);
-            }
+            LogAfterCollection(number, memAfter, _activationCount, list?.Count ?? 0, this, watch.Elapsed);
         }
 
         private async Task DeactivateActivationsFromCollector(List<ICollectibleGrainContext> list, CancellationToken cancellationToken)
         {
-            logger.LogInformation((int)ErrorCode.Catalog_ShutdownActivations_1, "Deactivating '{Count}' idle activations.", list.Count);
+            LogDeactivateActivationsFromCollector(list.Count);
             CatalogInstruments.ActivationShutdownViaCollection();
 
             var reason = GetDeactivationReason();
@@ -567,5 +547,32 @@ public List<ICollectibleGrainContext> CancelAll()
                 return result ?? nothing;
             }
         }
+
+        [LoggerMessage(
+            Level = LogLevel.Error,
+            Message = "Error while collecting activations."
+        )]
+        private partial void LogErrorWhileCollectingActivations(Exception exception);
+
+        [LoggerMessage(
+            EventId = (int)ErrorCode.Catalog_BeforeCollection,
+            Level = LogLevel.Debug,
+            Message = "Before collection #{CollectionNumber}: memory: {MemoryBefore}MB, #activations: {ActivationCount}, collector: {CollectorStatus}"
+        )]
+        private partial void LogBeforeCollection(int collectionNumber, long memoryBefore, int activationCount, ActivationCollector collectorStatus);
+
+        [LoggerMessage(
+            EventId = (int)ErrorCode.Catalog_AfterCollection,
+            Level = LogLevel.Debug,
+            Message =  "After collection #{CollectionNumber} memory: {MemoryAfter}MB, #activations: {ActivationCount}, collected {CollectedCount} activations, collector: {CollectorStatus}, collection time: {CollectionTime}"
+        )]
+        private partial void LogAfterCollection(int collectionNumber, long memoryAfter, int activationCount, int collectedCount, ActivationCollector collectorStatus, TimeSpan collectionTime);
+
+        [LoggerMessage(
+            EventId = (int)ErrorCode.Catalog_ShutdownActivations_1,
+            Level = LogLevel.Information,
+            Message = "Deactivating '{Count}' idle activations."
+        )]
+        private partial void LogDeactivateActivationsFromCollector(int count);
     }
 }