RabbitMq health checks

Signed-off-by: Tomasz Maruszak <maruszaktomasz@gmail.com>

Author: zarusz

src/SlimMessageBus.Host.RabbitMQ/RabbitMqChannelManager.cs

@@ -1,24 +1,25 @@
 namespace SlimMessageBus.Host.RabbitMQ;
 
-using Microsoft.Extensions.Logging;
 using global::RabbitMQ.Client;
 
+using Microsoft.Extensions.Logging;
+
 /// <summary>
 /// Manages RabbitMQ channel connection, reconnection, retry logic, and background timer.
 /// Acts as an IModel wrapper with automatic connection recovery.
 /// </summary>
-internal class RabbitMqChannelManager : IRabbitMqChannel, IDisposable
+internal partial class RabbitMqChannelManager : IRabbitMqChannel, IDisposable
 {
+    private readonly ILoggerFactory _loggerFactory;
     private readonly ILogger _logger;
     private readonly RabbitMqMessageBusSettings _providerSettings;
     private readonly MessageBusSettings _settings;
-    private readonly ILoggerFactory _loggerFactory;
     private readonly Func<bool> _isDisposingOrDisposed;
 
     private IConnection _connection;
     private IModel _channel;
     private readonly object _channelLock = new();
-    
+
     private readonly Timer _connectionRetryTimer;
     private readonly TimeSpan _connectionRetryInterval;
     private volatile bool _isConnecting;
@@ -33,16 +34,16 @@ public RabbitMqChannelManager(
         Func<bool> isDisposingOrDisposed)
     {
         _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
+        _logger = loggerFactory.CreateLogger<RabbitMqChannelManager>();
         _providerSettings = providerSettings ?? throw new ArgumentNullException(nameof(providerSettings));
         _settings = settings ?? throw new ArgumentNullException(nameof(settings));
         _isDisposingOrDisposed = isDisposingOrDisposed ?? throw new ArgumentNullException(nameof(isDisposingOrDisposed));
 
-        _logger = _loggerFactory.CreateLogger<RabbitMqChannelManager>();
 
         // Set up connection retry interval (default to NetworkRecoveryInterval or 10 seconds)
         var networkRecoveryInterval = _providerSettings.ConnectionFactory.NetworkRecoveryInterval;
         _connectionRetryInterval = networkRecoveryInterval == TimeSpan.Zero ? TimeSpan.FromSeconds(10) : networkRecoveryInterval;
-        
+
         // Initialize the retry timer (but don't start it yet)
         _connectionRetryTimer = new Timer(OnConnectionRetryTimer, null, Timeout.Infinite, Timeout.Infinite);
     }
@@ -67,7 +68,7 @@ await Retry.WithDelay(
                 {
                     if (ex is global::RabbitMQ.Client.Exceptions.BrokerUnreachableException && attempt < initialRetryCount)
                     {
-                        _logger.LogInformation(ex, "Retrying {Retry} of {RetryCount} connection to RabbitMQ...", attempt, initialRetryCount);
+                        LogRetryingConnection(attempt, initialRetryCount, ex);
                         return true;
                     }
                     return false;
@@ -78,15 +79,15 @@ await Retry.WithDelay(
 
             if (connectionEstablished)
             {
-                _logger.LogInformation("RabbitMQ connection established successfully");
+                LogConnectionEstablishedSuccessfully();
                 // Stop retry timer if connection was successful
                 _connectionRetryTimer.Change(Timeout.Infinite, Timeout.Infinite);
             }
         }
         catch (Exception e)
         {
-            _logger.LogError(e, "Could not initialize RabbitMQ connection after {RetryCount} attempts: {ErrorMessage}", initialRetryCount, e.Message);
-            
+            LogCouldNotInitializeConnection(initialRetryCount, e.Message, e);
+
             // Start continuous retry mechanism
             StartConnectionRetryTimer();
         }
@@ -102,10 +103,10 @@ public void EnsureChannel()
             // If channel is null, trigger immediate reconnection attempt
             if (!_isConnecting)
             {
-                _logger.LogWarning("Channel is not available, attempting immediate reconnection");
+                LogChannelNotAvailableAttemptingReconnection();
                 Task.Run(() => OnConnectionRetryTimer(null));
             }
-            
+
             throw new ProducerMessageBusException("The Channel is not available at this time");
         }
     }
@@ -116,7 +117,7 @@ public void EnsureChannel()
     public void ExecuteWithChannel(Action<IModel> action)
     {
         EnsureChannel();
-        
+
         lock (_channelLock)
         {
             action(_channel);
@@ -129,7 +130,7 @@ public void ExecuteWithChannel(Action<IModel> action)
     public T ExecuteWithChannel<T>(Func<IModel, T> func)
     {
         EnsureChannel();
-        
+
         lock (_channelLock)
         {
             return func(_channel);
@@ -178,7 +179,7 @@ private bool EstablishConnection()
         }
         catch (Exception ex)
         {
-            _logger.LogWarning(ex, "Failed to establish RabbitMQ connection: {ErrorMessage}", ex.Message);
+            LogFailedToEstablishConnection(ex.Message, ex);
             return false;
         }
     }
@@ -205,7 +206,7 @@ private void ProvisionTopology()
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Failed to provision RabbitMQ topology: {ErrorMessage}", ex.Message);
+            LogFailedToProvisionTopology(ex.Message, ex);
             throw;
         }
     }
@@ -214,9 +215,8 @@ private void OnConnectionShutdown(object sender, ShutdownEventArgs e)
     {
         if (!_isDisposingOrDisposed())
         {
-            _logger.LogWarning("RabbitMQ connection shutdown detected. Reason: {Reason}, Initiator: {Initiator}", 
-                e.ReplyText, e.Initiator);
-            
+            LogConnectionShutdownDetected(e.ReplyText, e.Initiator);
+
             // Start retry timer if not already running
             StartConnectionRetryTimer();
         }
@@ -226,7 +226,7 @@ private void StartConnectionRetryTimer()
     {
         if (!_isConnecting && !_isDisposingOrDisposed())
         {
-            _logger.LogInformation("Starting RabbitMQ connection retry timer with interval: {Interval}", _connectionRetryInterval);
+            LogStartingConnectionRetryTimer(_connectionRetryInterval);
             _connectionRetryTimer.Change(_connectionRetryInterval, _connectionRetryInterval);
         }
     }
@@ -241,7 +241,7 @@ private void OnConnectionRetryTimer(object state)
         {
             if (_connection?.IsOpen == true && _channel?.IsOpen == true)
             {
-                _logger.LogDebug("RabbitMQ connection is healthy, stopping retry timer");
+                LogConnectionIsHealthy();
                 _connectionRetryTimer.Change(Timeout.Infinite, Timeout.Infinite);
                 return;
             }
@@ -250,22 +250,22 @@ private void OnConnectionRetryTimer(object state)
         _isConnecting = true;
         try
         {
-            _logger.LogInformation("Attempting to reconnect to RabbitMQ...");
-            
+            LogAttemptingToReconnect();
+
             var success = EstablishConnection();
             if (success)
             {
-                _logger.LogInformation("RabbitMQ reconnection successful");
+                LogReconnectionSuccessful();
                 _connectionRetryTimer.Change(Timeout.Infinite, Timeout.Infinite);
             }
             else
             {
-                _logger.LogWarning("RabbitMQ reconnection failed, will retry in {Interval}", _connectionRetryInterval);
+                LogReconnectionFailed(_connectionRetryInterval);
             }
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error during RabbitMQ reconnection attempt: {ErrorMessage}", ex.Message);
+            LogErrorDuringReconnectionAttempt(ex.Message, ex);
         }
         finally
         {
@@ -315,11 +315,139 @@ public void Dispose()
         {
             // Unsubscribe from events before disposing
             _connection.ConnectionShutdown -= OnConnectionShutdown;
-            
+
             CloseAndDisposeConnection(_connection);
             _connection = null;
         }
 
         GC.SuppressFinalize(this);
     }
-}
+
+    #region Logging
+
+    [LoggerMessage(
+        EventId = 0,
+        Level = LogLevel.Information,
+        Message = "Retrying {Retry} of {RetryCount} connection to RabbitMQ...")]
+    private partial void LogRetryingConnection(int retry, int retryCount, Exception ex);
+
+    [LoggerMessage(
+        EventId = 1,
+        Level = LogLevel.Information,
+        Message = "RabbitMQ connection established successfully")]
+    private partial void LogConnectionEstablishedSuccessfully();
+
+    [LoggerMessage(
+        EventId = 2,
+        Level = LogLevel.Error,
+        Message = "Could not initialize RabbitMQ connection after {RetryCount} attempts: {ErrorMessage}")]
+    private partial void LogCouldNotInitializeConnection(int retryCount, string errorMessage, Exception ex);
+
+    [LoggerMessage(
+        EventId = 3,
+        Level = LogLevel.Warning,
+        Message = "Channel is not available, attempting immediate reconnection")]
+    private partial void LogChannelNotAvailableAttemptingReconnection();
+
+    [LoggerMessage(
+        EventId = 4,
+        Level = LogLevel.Warning,
+        Message = "Failed to establish RabbitMQ connection: {ErrorMessage}")]
+    private partial void LogFailedToEstablishConnection(string errorMessage, Exception ex);
+
+    [LoggerMessage(
+        EventId = 5,
+        Level = LogLevel.Error,
+        Message = "Failed to provision RabbitMQ topology: {ErrorMessage}")]
+    private partial void LogFailedToProvisionTopology(string errorMessage, Exception ex);
+
+    [LoggerMessage(
+        EventId = 6,
+        Level = LogLevel.Warning,
+        Message = "RabbitMQ connection shutdown detected. Reason: {Reason}, Initiator: {Initiator}")]
+    private partial void LogConnectionShutdownDetected(string reason, object initiator);
+
+    [LoggerMessage(
+        EventId = 7,
+        Level = LogLevel.Information,
+        Message = "Starting RabbitMQ connection retry timer with interval: {Interval}")]
+    private partial void LogStartingConnectionRetryTimer(TimeSpan interval);
+
+    [LoggerMessage(
+        EventId = 8,
+        Level = LogLevel.Debug,
+        Message = "RabbitMQ connection is healthy, stopping retry timer")]
+    private partial void LogConnectionIsHealthy();
+
+    [LoggerMessage(
+        EventId = 9,
+        Level = LogLevel.Information,
+        Message = "Attempting to reconnect to RabbitMQ...")]
+    private partial void LogAttemptingToReconnect();
+
+    [LoggerMessage(
+        EventId = 10,
+        Level = LogLevel.Information,
+        Message = "RabbitMQ reconnection successful")]
+    private partial void LogReconnectionSuccessful();
+
+    [LoggerMessage(
+        EventId = 11,
+        Level = LogLevel.Warning,
+        Message = "RabbitMQ reconnection failed, will retry in {Interval}")]
+    private partial void LogReconnectionFailed(TimeSpan interval);
+
+    [LoggerMessage(
+        EventId = 12,
+        Level = LogLevel.Error,
+        Message = "Error during RabbitMQ reconnection attempt: {ErrorMessage}")]
+    private partial void LogErrorDuringReconnectionAttempt(string errorMessage, Exception ex);
+
+    #endregion
+}
+
+#if NETSTANDARD2_0
+
+internal partial class RabbitMqChannelManager
+{
+    private partial void LogRetryingConnection(int retry, int retryCount, Exception ex)
+        => _logger.LogInformation(ex, "Retrying {Retry} of {RetryCount} connection to RabbitMQ...", retry, retryCount);
+
+    private partial void LogConnectionEstablishedSuccessfully()
+        => _logger.LogInformation("RabbitMQ connection established successfully");
+
+    private partial void LogCouldNotInitializeConnection(int retryCount, string errorMessage, Exception ex)
+        => _logger.LogError(ex, "Could not initialize RabbitMQ connection after {RetryCount} attempts: {ErrorMessage}", retryCount, errorMessage);
+
+    private partial void LogChannelNotAvailableAttemptingReconnection()
+        => _logger.LogWarning("Channel is not available, attempting immediate reconnection");
+
+    private partial void LogFailedToEstablishConnection(string errorMessage, Exception ex)
+        => _logger.LogWarning(ex, "Failed to establish RabbitMQ connection: {ErrorMessage}", errorMessage);
+
+    private partial void LogFailedToProvisionTopology(string errorMessage, Exception ex)
+        => _logger.LogError(ex, "Failed to provision RabbitMQ topology: {ErrorMessage}", errorMessage);
+
+    private partial void LogConnectionShutdownDetected(string reason, object initiator)
+        => _logger.LogWarning("RabbitMQ connection shutdown detected. Reason: {Reason}, Initiator: {Initiator}", reason, initiator);
+
+    private partial void LogStartingConnectionRetryTimer(TimeSpan interval)
+        => _logger.LogInformation("Starting RabbitMQ connection retry timer with interval: {Interval}", interval);
+
+    private partial void LogConnectionIsHealthy()
+        => _logger.LogDebug("RabbitMQ connection is healthy, stopping retry timer");
+
+    private partial void LogAttemptingToReconnect()
+        => _logger.LogInformation("Attempting to reconnect to RabbitMQ...");
+
+    private partial void LogReconnectionSuccessful()
+        => _logger.LogInformation("RabbitMQ reconnection successful");
+
+    private partial void LogReconnectionFailed(TimeSpan interval)
+        => _logger.LogWarning("RabbitMQ reconnection failed, will retry in {Interval}", interval);
+
+    private partial void LogErrorDuringReconnectionAttempt(string errorMessage, Exception ex)
+        => _logger.LogError(ex, "Error during RabbitMQ reconnection attempt: {ErrorMessage}", errorMessage);
+}
+
+#endif