Healthcheck implementation

[s4ndr0ne]

Hello,

In my projects, I always need to verify that the client is actually connected to the cluster. Do you think it's a good idea to implement this healtchek extension?

Implementation example:

Create a method in ActiveMqHostingExtensions:

public static IHealthChecksBuilder AddActiveMqHealthChecks(this IHealthChecksBuilder builder,
            string name,
            Func<IServiceProvider, IConnection> factory = null)
        {
            // Register the health check factory in the DI container
            builder.Services.AddSingleton(sp => new ActiveMqHealthCheckFactory(name, factory));

            // Register the health check using the typed approach
            return builder.AddTypeActivatedCheck<ActiveMHealthCheck>(name,
                failureStatus: HealthStatus.Unhealthy,
                tags: new[] { "active-mq" });
        }

Healtcheck implementation:

public class ActiveMqHealthCheckFactory
    {
        public string Name { get; }
        public Func<IServiceProvider, IConnection> Factory { get; }

        public ActiveMqHealthCheckFactory(string name, Func<IServiceProvider, IConnection> factory)
        {
            Name = name;
            Factory = factory;
        }
    }
    
    public class ActiveMHealthCheck : IHealthCheck
    {
        private readonly IServiceProvider _serviceProvider;
        private readonly ActiveMqHealthCheckFactory _factory;

        public ActiveMHealthCheck(IServiceProvider serviceProvider, ActiveMqHealthCheckFactory factory)
        {
            _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
            _factory = factory ?? throw new ArgumentNullException(nameof(factory));
        }

        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
        {
            try
            {
                IConnection connection;

                if (_factory.Factory != null)
                {
                    connection = _factory.Factory(_serviceProvider);
                }
                else
                {
                    // Use ConnectionProvider to get connection by name
                    var connectionProvider = _serviceProvider.GetRequiredService<ConnectionProvider>();
                    connection = await connectionProvider.GetConnectionAsync(_factory.Name, cancellationToken);
                }

                if (connection == null || !connection.IsOpened)
                {
                    return HealthCheckResult.Unhealthy("Connection is not opened");
                }

                return HealthCheckResult.Healthy();
            }
            catch (Exception ex)
            {
                return new HealthCheckResult(context.Registration.FailureStatus, exception: ex);
            }
        }
    }

Startup registration:

services
                .AddHealthChecks()
                .AddActiveMqHealthChecks("my-artemis-cluster");

To do this you need to upgrade the packages in ArtemisNetClient.Extensions.Hosting.csproj:

 <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="8.0.18" />
    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.1" />
  </ItemGroup>

Cheers!

[Havret]

Hi @s4ndr0ne,

Thanks for the suggestion, having a health check is definitely a must for production deployments.

That said, I see one potential issue with your current implementation. It creates a new connection to perform the health check, which may not accurately reflect the actual health of the connection your application is using. This can lead to false positives. Your health check might pass even though the main connection is stuck trying to recover after a failover.

It also looks like the connection created inside the health check isn’t being disposed, which could lead to resource leakage over time, especially if the health check runs frequently. That’s something to watch out for.

In my experience, a more reliable approach is to monitor the connection your app is actively using. You can check the IConnection.IsOpened property directly.

Additionally, the IConnection interface exposes three helpful events you can wire up:

• ConnectionClosed → map to Unhealthy
• ConnectionRecovered → map to Healthy
• ConnectionRecoveryError → map to Degraded or Unhealthy depending on context

These give you better visibility into the connection lifecycle and can be hooked into custom health check logic.

It might be worth considering a dedicated package with built-in health check support.

If you think that would simplify usage, feel free to open an issue and we can discuss it further.

Best,
Havret

[s4ndr0ne]

Yes @Havret I agree with what you say,
this is my actual implementation:

.ConfigureConnection((serviceProvider, connection) =>
            {  
                connection.ConnectionClosed += ArtemisHealthCheck.ConnectionClosed;
                connection.ConnectionRecovered += ArtemisHealthCheck.ConnectionRecovered;                
                connection.ConnectionRecoveryError += ArtemisHealthCheck.ConnectionRecoveryError; 

            })

class ArtemisHealthCheck : IHealthCheck
    {
        private static bool IsOpen= true;      
        private static string Description = "Open";        

        public static void ConnectionRecovered(object? sender, ConnectionRecoveredEventArgs e)
        {
            IsOpen= true;
            Description = "Recovered";
        }

        public static void ConnectionRecoveryError(object? sender, ConnectionRecoveryErrorEventArgs e)
        {
            IsOpen= false;
            Description = "RecoveryError";
        }

        public static void ConnectionClosed(object? sender, ConnectionClosedEventArgs e)
        {
            IsOpen= false;   
            Description = "Closed";
        }

        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
        {
            HealthCheckResult result = new(IsOpen? HealthStatus.Healthy : HealthStatus.Unhealthy, description: Description);
            return await Task.FromResult(result);
        }
    }

Recording it like this:
services.AddActiveMq(name: "my-artemis-cluster", ....
.AddActiveMqHealthChecks("my-artemis-cluster");

Shouldn't it refer to the application connection?
connection = await connectionProvider.GetConnectionAsync(_factory.Name, cancellationToken);

And you are absolutely right to make it a dedicated package.

I tried to implement it if you want you can take a look at it:
s4ndr0ne@6239d6a

cheers!

[Havret]

@s4ndr0ne,

Shouldn't it refer to the application connection?
connection = await connectionProvider.GetConnectionAsync(_factory.Name, cancellationToken);

You're right. Sorry about that. It seems I missed the second branch of this if statement.

This s4ndr0ne@6239d6a looks really awesome. Would you consider submitting a PR?

Best,
Havret

[s4ndr0ne]

Yes,
I would certainly be very grateful.
Can I proceed directly with the pull request?

Best
Alessandro

[Havret]

Yes, please. We can discuss the minutiae as part of the normal PR review flow.