[RabbitMQ] Reusing healthy connection

src/HealthChecks.RabbitMQ/DependencyInjection/RabbitMQHealthCheckBuilderExtensions.cs

@@ -28,7 +28,7 @@ public static IHealthChecksBuilder AddRabbitMQ(this IHealthChecksBuilder builder
         {
             return builder.Add(new HealthCheckRegistration(
                 name ?? NAME,
-                sp => new RabbitMQHealthCheck(rabbitMQConnectionString, sslOption),
+                new RabbitMQHealthCheck(rabbitMQConnectionString, sslOption),
                 failureStatus,
                 tags,
                 timeout));

src/HealthChecks.RabbitMQ/RabbitMQHealthCheck.cs

@@ -1,72 +1,84 @@
-using Microsoft.Extensions.Diagnostics.HealthChecks;
-using RabbitMQ.Client;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace HealthChecks.RabbitMQ
-{
-    public class RabbitMQHealthCheck
-        : IHealthCheck
-    {
-        private readonly Lazy<IConnectionFactory> _lazyConnectionFactory;
-        private readonly IConnection _rmqConnection;
-
-        public RabbitMQHealthCheck(string rabbitMqConnectionString, SslOption sslOption = null)
-        {
-            if (rabbitMqConnectionString == null) throw new ArgumentNullException(nameof(rabbitMqConnectionString));
-
-            _lazyConnectionFactory = new Lazy<IConnectionFactory>(() => new ConnectionFactory()
-            {
-                Uri = new Uri(rabbitMqConnectionString),
-                Ssl = sslOption ?? new SslOption()
-            });
-        }
-
-        public RabbitMQHealthCheck(IConnection connection)
-        {
-            _rmqConnection = connection ?? throw new ArgumentNullException(nameof(connection));
-        }
-
-        public RabbitMQHealthCheck(IConnectionFactory connectionFactory)
-        {
-            _lazyConnectionFactory = new Lazy<IConnectionFactory>(() => 
-                connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory)));
-        }
-
-        public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
-        {
-            try
-            {
-                if (_rmqConnection != null)
-                {
-                    return TestConnection(_rmqConnection);
-                }
-
-                using (var connection = CreateConnection(_lazyConnectionFactory.Value))
-                {
-                    return TestConnection(connection);
-                }
-            }
-            catch (Exception ex)
-            {
-                return Task.FromResult(
-                    new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
-            }
-        }
-
-        private static Task<HealthCheckResult> TestConnection(IConnection connection)
-        {
-            using (var channel = connection.CreateModel())
-            {
-                return Task.FromResult(
-                    HealthCheckResult.Healthy());
-            }
-        }
-
-        private static IConnection CreateConnection(IConnectionFactory connectionFactory)
-        {
-            return connectionFactory.CreateConnection("Health Check Connection");
-        }
-    }
-}
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using RabbitMQ.Client;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace HealthChecks.RabbitMQ
+{
+    public class RabbitMQHealthCheck
+        : IHealthCheck
+    {
+        private readonly IConnectionFactory _connectionFactory;
+        private IConnection _rmqConnection;
+
+        public RabbitMQHealthCheck(string rabbitMqConnectionString, SslOption sslOption = null)
+        {
+            var connectionFactory = new ConnectionFactory
+            {
+                Uri = new Uri(rabbitMqConnectionString ?? throw new ArgumentNullException(nameof(rabbitMqConnectionString))),
+                AutomaticRecoveryEnabled = true // Explicitly setting to ensure this is true (in case the default changes)
+            };
+            if (sslOption != null)
+            {
+                connectionFactory.Ssl = sslOption;
+            }
+            _connectionFactory = connectionFactory;
+        }
+
+        public RabbitMQHealthCheck(IConnection connection)
+        {
+            _rmqConnection = connection ?? throw new ArgumentNullException(nameof(connection));
+        }
+
+        public RabbitMQHealthCheck(IConnectionFactory connectionFactory)
+        {
+            _connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
+        }
+
+        public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                // If no factory was provided then we're stuck using the passed in connection
+                // regardless of the state it may be in. We don't have a way to attempt to
+                // create a new connection :(
+                if (_connectionFactory == null)
+                {
+                    return TestConnection(_rmqConnection);
+                }
+
+                if (_rmqConnection != null && _rmqConnection.IsOpen == false)
+                {
+                    _rmqConnection.Close(0);
+                    _rmqConnection = null;
+                }
+                if (_rmqConnection == null)
+                {
+                    _rmqConnection = CreateConnection(_connectionFactory);
+                }
+
+                return TestConnection(_rmqConnection);
+            }
+            catch (Exception ex)
+            {
+                return Task.FromResult(
+                    new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
+            }
+        }
+
+        private static Task<HealthCheckResult> TestConnection(IConnection connection)
+        {
+            using (connection.CreateModel())
+            {
+                return Task.FromResult(
+                    HealthCheckResult.Healthy());
+            }
+        }
+
+        private static IConnection CreateConnection(IConnectionFactory connectionFactory)
+        {
+            return connectionFactory.CreateConnection("Health Check Connection");
+        }
+    }
+}

test/UnitTests/DependencyInjection/RabbitMQ/RabbitMQUnitTests.cs

@@ -1,46 +1,56 @@
-using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using FluentAssertions;
 using HealthChecks.RabbitMQ;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
 using Microsoft.Extensions.Options;
 using System.Linq;
+using System.Threading.Tasks;
+using RabbitMQ.Client;
+using RabbitMQ.Client.Events;
 using Xunit;
 
 namespace UnitTests.HealthChecks.DependencyInjection.RabbitMQ
 {
     public class rabbitmq_registration_should
     {
+        private string _fakeConnectionString = "amqp://server";
+        private string _defaultCheckName = "rabbitmq";
+
         [Fact]
         public void add_health_check_when_properly_configured()
         {
             var services = new ServiceCollection();
             services.AddHealthChecks()
-                .AddRabbitMQ(rabbitMQConnectionString: "connectionstring");
+                .AddRabbitMQ(rabbitMQConnectionString: _fakeConnectionString);
 
             var serviceProvider = services.BuildServiceProvider();
             var options = serviceProvider.GetService<IOptions<HealthCheckServiceOptions>>();
 
             var registration = options.Value.Registrations.First();
             var check = registration.Factory(serviceProvider);
 
-            registration.Name.Should().Be("rabbitmq");
+            registration.Name.Should().Be(_defaultCheckName);
             check.GetType().Should().Be(typeof(RabbitMQHealthCheck));
         }
 
         [Fact]
         public void add_named_health_check_when_properly_configured()
         {
             var services = new ServiceCollection();
+            var customCheckName = "my-"+ _defaultCheckName;
+
             services.AddHealthChecks()
-                .AddRabbitMQ("connectionstring", name: "my-rabbitmq");
+                .AddRabbitMQ(_fakeConnectionString, name: customCheckName);
 
             var serviceProvider = services.BuildServiceProvider();
             var options = serviceProvider.GetService<IOptions<HealthCheckServiceOptions>>();
 
             var registration = options.Value.Registrations.First();
             var check = registration.Factory(serviceProvider);
 
-            registration.Name.Should().Be("my-rabbitmq");
+            registration.Name.Should().Be(customCheckName);
             check.GetType().Should().Be(typeof(RabbitMQHealthCheck));
         }
     }