Add async Redis connection multiplexer factory

Author: maikebing

README.md

@@ -233,6 +233,18 @@ public void ConfigureServices(IServiceCollection services)
 
 Each HealthCheck registration supports also name, tags, failure status and other optional parameters.
 
+For Redis connections that require asynchronous setup, use the async multiplexer factory and return a shared
+`IConnectionMultiplexer` instance:
+
+```csharp
+services.AddHealthChecks()
+    .AddRedis(async (_, cancellationToken) =>
+    {
+        // Resolve credentials and reuse the multiplexer in application code.
+        return await GetSharedRedisConnectionMultiplexerAsync(cancellationToken);
+    });
+```
+
 ```csharp
 public void ConfigureServices(IServiceCollection services)
 {

docs/reference/getting-started.md

@@ -36,6 +36,19 @@ services
 
 Each builder extension also supports operational metadata such as a custom name, tags, a failure status, and a timeout.
 
+When Redis connection setup is asynchronous, use the async multiplexer factory. The factory should return a shared
+`IConnectionMultiplexer`; any asynchronous connection-string or credential resolution can happen inside the factory.
+
+```csharp
+services
+    .AddHealthChecks()
+    .AddRedis(async (_, cancellationToken) =>
+    {
+        // Resolve credentials and reuse the multiplexer in application code.
+        return await GetSharedRedisConnectionMultiplexerAsync(cancellationToken);
+    });
+```
+
 ```csharp
 services
     .AddHealthChecks()

src/HealthChecks.Redis/DependencyInjection/RedisHealthCheckBuilderExtensions.cs

@@ -120,4 +120,35 @@ public static IHealthChecksBuilder AddRedis(
            tags,
            timeout));
     }
+
+    /// <summary>
+    /// Add a health check for Redis services using an asynchronous connection factory.
+    /// </summary>
+    /// <param name="builder">The <see cref="IHealthChecksBuilder"/>.</param>
+    /// <param name="connectionMultiplexerFactory">A factory to asynchronously build the Redis connection to use.</param>
+    /// <param name="name">The health check name. Optional. If <c>null</c> the type name 'redis' will be used for the name.</param>
+    /// <param name="failureStatus">
+    /// The <see cref="HealthStatus"/> that should be reported when the health check fails. Optional. If <c>null</c> then
+    /// the default status of <see cref="HealthStatus.Unhealthy"/> will be reported.
+    /// </param>
+    /// <param name="tags">A list of tags that can be used to filter sets of health checks. Optional.</param>
+    /// <param name="timeout">An optional <see cref="TimeSpan"/> representing the timeout of the check.</param>
+    /// <returns>The specified <paramref name="builder"/>.</returns>
+    public static IHealthChecksBuilder AddRedis(
+        this IHealthChecksBuilder builder,
+        Func<IServiceProvider, CancellationToken, Task<IConnectionMultiplexer>> connectionMultiplexerFactory,
+        string? name = default,
+        HealthStatus? failureStatus = default,
+        IEnumerable<string>? tags = default,
+        TimeSpan? timeout = default)
+    {
+        Guard.ThrowIfNull(connectionMultiplexerFactory);
+
+        return builder.Add(new HealthCheckRegistration(
+           name ?? NAME,
+           sp => new RedisHealthCheck(cancellationToken => connectionMultiplexerFactory(sp, cancellationToken)),
+           failureStatus,
+           tags,
+           timeout));
+    }
 }

src/HealthChecks.Redis/RedisHealthCheck.cs

@@ -13,6 +13,7 @@ public class RedisHealthCheck : IHealthCheck
     private readonly string? _redisConnectionString;
     private readonly IConnectionMultiplexer? _connectionMultiplexer;
     private readonly Func<IConnectionMultiplexer>? _connectionMultiplexerFactory;
+    private readonly Func<CancellationToken, Task<IConnectionMultiplexer>>? _asyncConnectionMultiplexerFactory;
 
     public RedisHealthCheck(string redisConnectionString)
     {
@@ -36,7 +37,12 @@ public RedisHealthCheck(IConnectionMultiplexer connectionMultiplexer)
     /// </remarks>
     internal RedisHealthCheck(Func<IConnectionMultiplexer> connectionMultiplexerFactory)
     {
-        _connectionMultiplexerFactory = connectionMultiplexerFactory;
+        _connectionMultiplexerFactory = Guard.ThrowIfNull(connectionMultiplexerFactory);
+    }
+
+    internal RedisHealthCheck(Func<CancellationToken, Task<IConnectionMultiplexer>> connectionMultiplexerFactory)
+    {
+        _asyncConnectionMultiplexerFactory = Guard.ThrowIfNull(connectionMultiplexerFactory);
     }
 
     /// <inheritdoc />
@@ -46,6 +52,19 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
         {
             IConnectionMultiplexer? connection = _connectionMultiplexer ?? _connectionMultiplexerFactory?.Invoke();
 
+            if (connection is null && _asyncConnectionMultiplexerFactory is not null)
+            {
+                try
+                {
+                    connection = Guard.ThrowIfNull(
+                        await _asyncConnectionMultiplexerFactory(cancellationToken).ConfigureAwait(false));
+                }
+                catch (OperationCanceledException)
+                {
+                    return new HealthCheckResult(context.Registration.FailureStatus, description: "Healthcheck timed out");
+                }
+            }
+
             if (_redisConnectionString is not null && !_connections.TryGetValue(_redisConnectionString, out connection))
             {
                 try

test/HealthChecks.Redis.Tests/DependencyInjection/RegistrationTests.cs

@@ -109,4 +109,68 @@ public void add_health_check_with_connection_multiplexer_when_properly_configure
         // the factory is called when it's used for the first time, as it can throw
         factoryCalled.ShouldBeFalse();
     }
-}
+
+    [Fact]
+    public async Task add_health_check_with_async_connection_multiplexer_factory_when_properly_configured()
+    {
+        var connectionMultiplexer = Substitute.For<IConnectionMultiplexer>();
+        connectionMultiplexer.GetEndPoints(configuredOnly: true).Returns([]);
+
+        var services = new ServiceCollection();
+        var factoryCalled = false;
+        CancellationToken capturedCancellationToken = default;
+
+        services.AddHealthChecks()
+            .AddRedis(async (_, cancellationToken) =>
+            {
+                factoryCalled = true;
+                capturedCancellationToken = cancellationToken;
+                await Task.Yield();
+                return connectionMultiplexer;
+            });
+
+        using var serviceProvider = services.BuildServiceProvider();
+        var options = serviceProvider.GetRequiredService<IOptions<HealthCheckServiceOptions>>();
+
+        var registration = options.Value.Registrations.First();
+        var check = registration.Factory(serviceProvider);
+
+        registration.Name.ShouldBe("redis");
+        check.ShouldBeOfType<RedisHealthCheck>();
+        factoryCalled.ShouldBeFalse();
+
+        using var cancellationTokenSource = new CancellationTokenSource();
+        var result = await check.CheckHealthAsync(
+            new HealthCheckContext { Registration = registration },
+            cancellationTokenSource.Token);
+
+        result.Status.ShouldBe(HealthStatus.Healthy);
+        factoryCalled.ShouldBeTrue();
+        capturedCancellationToken.ShouldBe(cancellationTokenSource.Token);
+    }
+
+    [Fact]
+    public async Task return_timeout_when_async_connection_multiplexer_factory_is_cancelled()
+    {
+        using var cancellationTokenSource = new CancellationTokenSource();
+        cancellationTokenSource.Cancel();
+
+        var services = new ServiceCollection();
+        services.AddHealthChecks()
+            .AddRedis((_, cancellationToken) =>
+                Task.FromCanceled<IConnectionMultiplexer>(cancellationToken));
+
+        using var serviceProvider = services.BuildServiceProvider();
+        var registration = serviceProvider
+            .GetRequiredService<IOptions<HealthCheckServiceOptions>>()
+            .Value.Registrations.First();
+        var check = registration.Factory(serviceProvider);
+
+        var result = await check.CheckHealthAsync(
+            new HealthCheckContext { Registration = registration },
+            cancellationTokenSource.Token);
+
+        result.Status.ShouldBe(HealthStatus.Unhealthy);
+        result.Description.ShouldBe("Healthcheck timed out");
+    }
+}

test/HealthChecks.Redis.Tests/HealthChecks.Redis.approved.txt

@@ -14,6 +14,7 @@ namespace Microsoft.Extensions.DependencyInjection
         public static Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder AddRedis(this Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder builder, StackExchange.Redis.IConnectionMultiplexer connectionMultiplexer, string? name = null, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus = default, System.Collections.Generic.IEnumerable<string>? tags = null, System.TimeSpan? timeout = default) { }
         public static Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder AddRedis(this Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder builder, System.Func<System.IServiceProvider, StackExchange.Redis.IConnectionMultiplexer> connectionMultiplexerFactory, string? name = null, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus = default, System.Collections.Generic.IEnumerable<string>? tags = null, System.TimeSpan? timeout = default) { }
         public static Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder AddRedis(this Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder builder, System.Func<System.IServiceProvider, string> connectionStringFactory, string? name = null, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus = default, System.Collections.Generic.IEnumerable<string>? tags = null, System.TimeSpan? timeout = default) { }
+        public static Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder AddRedis(this Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder builder, System.Func<System.IServiceProvider, System.Threading.CancellationToken, System.Threading.Tasks.Task<StackExchange.Redis.IConnectionMultiplexer>> connectionMultiplexerFactory, string? name = null, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus = default, System.Collections.Generic.IEnumerable<string>? tags = null, System.TimeSpan? timeout = default) { }
         public static Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder AddRedis(this Microsoft.Extensions.DependencyInjection.IHealthChecksBuilder builder, string redisConnectionString, string? name = null, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus = default, System.Collections.Generic.IEnumerable<string>? tags = null, System.TimeSpan? timeout = default) { }
     }
 }