[WIP] Dependency Injected HealthChecks (#659)

* Add dependency injection support health checks.

- Add WithHealthCheck<T>() generic methods for DI-resolved health checks
- Support both simple registration and template-based configuration
- Implement DiResolvedHealthCheck<T> wrapper for lazy DI resolution

* Updated CoreApiSpec.ApproveCore.verified.txt to include new APIs

* Reverted global.json

* Removed DI registration logic. Now should throw 'InvalidOperationException' if the health check type is not registered

* eliminate need for HealthCheck ServiceCollection registrations

* API approvals

* fixed DI demo

---------

Co-authored-by: Emir Birgiç <emir.birgic@theyr.com>
Co-authored-by: (ノ°Д°）ノ︵ ┻━┻ <beminee@users.noreply.github.com>

Author: 3 people

src/Akka.Hosting.API.Tests/verify/CoreApiSpec.ApproveCore.verified.txt

@@ -46,6 +46,8 @@ namespace Akka.Hosting
             where T : Akka.Actor.IExtensionId { }
         public Akka.Hosting.AkkaConfigurationBuilder WithExtensions(params System.Type[] extensions) { }
         public Akka.Hosting.AkkaConfigurationBuilder WithHealthCheck(Akka.Hosting.AkkaHealthCheckRegistration registration) { }
+        public Akka.Hosting.AkkaConfigurationBuilder WithHealthCheck<T>(string name, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus = default, System.Collections.Generic.IEnumerable<string>? tags = null, System.TimeSpan? timeout = default)
+            where T :  class, Akka.Hosting.IAkkaHealthCheck { }
     }
     public sealed class AkkaHealthCheckContext
     {
@@ -58,8 +60,8 @@ namespace Akka.Hosting
     {
         public AkkaHealthCheckRegistration(string name, Akka.Hosting.IAkkaHealthCheck instance, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus, System.Collections.Generic.IEnumerable<string>? tags) { }
         public AkkaHealthCheckRegistration(string name, Akka.Hosting.IAkkaHealthCheck instance, Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus? failureStatus, System.Collections.Generic.IEnumerable<string>? tags, System.TimeSpan? timeout) { }
+        public System.Func<System.IServiceProvider, Akka.Hosting.IAkkaHealthCheck> Factory { get; set; }
         public Microsoft.Extensions.Diagnostics.HealthChecks.HealthStatus FailureStatus { get; set; }
-        public Akka.Hosting.IAkkaHealthCheck HealthCheck { get; set; }
         public string Name { get; set; }
         public System.Collections.Generic.ISet<string> Tags { get; }
         public System.TimeSpan Timeout { get; set; }

src/Akka.Hosting.Tests/HealthChecks/HealthChecksSpec.cs

@@ -6,16 +6,19 @@
 using Akka.Hosting.HealthChecks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Microsoft.Extensions.Hosting;
 using Xunit;
 using Xunit.Abstractions;
 
 namespace Akka.Hosting.Tests.HealthChecks;
 
 public class HealthChecksSpec : TestKit.TestKit
 {
-    public HealthChecksSpec(ITestOutputHelper output) 
-        : base(output: output){ }
-    
+    public HealthChecksSpec(ITestOutputHelper output)
+        : base(output: output)
+    {
+    }
+
     private class FooActor : UntypedActor
     {
         protected override void OnReceive(object message)
@@ -28,61 +31,64 @@ protected override void ConfigureAkka(AkkaConfigurationBuilder builder, IService
         builder
             .WithActorSystemLivenessCheck() // have to opt-in to the built-in health check
             .WithHealthCheck("FooActor alive", async (system, registry, cancellationToken) =>
-        {
-            /*
-             * N.B. CancellationToken is set by the call to MSFT.EXT.DIAGNOSTICS.HEALTHCHECK,
-             * so that value could be "infinite" by default.
-             *
-             * Therefore, it might be a really, really good idea to guard this with a non-infinite
-             * timeout via a LinkedCancellationToken here.
-             */
-            try
             {
-                var fooActor = await registry.GetAsync<FooActor>(cancellationToken);
-
+                /*
+                 * N.B. CancellationToken is set by the call to MSFT.EXT.DIAGNOSTICS.HEALTHCHECK,
+                 * so that value could be "infinite" by default.
+                 *
+                 * Therefore, it might be a really, really good idea to guard this with a non-infinite
+                 * timeout via a LinkedCancellationToken here.
+                 */
                 try
                 {
-                    var r = await fooActor.Ask<ActorIdentity>(new Identify("foo"), cancellationToken: cancellationToken);
-                    if (r.Subject.IsNobody())
-                        return HealthCheckResult.Unhealthy("FooActor was alive but is now dead");
+                    var fooActor = await registry.GetAsync<FooActor>(cancellationToken);
+
+                    try
+                    {
+                        var r = await fooActor.Ask<ActorIdentity>(new Identify("foo"),
+                            cancellationToken: cancellationToken);
+                        if (r.Subject.IsNobody())
+                            return HealthCheckResult.Unhealthy("FooActor was alive but is now dead");
+                    }
+                    catch (Exception e)
+                    {
+                        return HealthCheckResult.Degraded("FooActor found but non-responsive", e);
+                    }
                 }
-                catch (Exception e)
+                catch (Exception e2)
                 {
-                    return HealthCheckResult.Degraded("FooActor found but non-responsive", e);
+                    return HealthCheckResult.Unhealthy("FooActor not found in registry", e2);
                 }
-            }
-            catch (Exception e2)
-            {
-                return HealthCheckResult.Unhealthy("FooActor not found in registry", e2);
-            }
 
-            return HealthCheckResult.Healthy("fooActor found and responsive");
-        });
+                return HealthCheckResult.Healthy("fooActor found and responsive");
+            });
     }
 
     [Fact]
     public async Task ShouldHaveDefaultHealthCheckRegistration()
     {
         // arrange
         var configurationBuilder = Host.Services.GetRequiredService<AkkaConfigurationBuilder>();
-        
+
         // act
-        
+
         // assert
         Assert.Equal(2, configurationBuilder.HealthChecks.Count); // 1 built-in, 1 custom
-        
+
         // find the built-in implementation
-        var actorSystemHealthCheckRegistration = configurationBuilder.HealthChecks.Values.Single(c => c.HealthCheck is ActorSystemLivenessCheck);
+        var actorSystemHealthCheckRegistration =
+            configurationBuilder.HealthChecks.Values.Single(c => c.Factory(Host.Services) is ActorSystemLivenessCheck);
         var akkaHealthCheckContext = new AkkaHealthCheckContext(Sys)
             { Registration = actorSystemHealthCheckRegistration.ToHealthCheckRegistration() };
-        
+
         // invoke the actorSystem liveness check
-        var healthCheckResult = await actorSystemHealthCheckRegistration.HealthCheck.CheckHealthAsync(akkaHealthCheckContext, CancellationToken.None);
-        
+        var healthCheck = actorSystemHealthCheckRegistration.Factory(Host.Services);
+        var healthCheckResult = await healthCheck.CheckHealthAsync(akkaHealthCheckContext, CancellationToken.None);
+
         // assert - system is alive, health check should be healthy
         Assert.Equal(HealthStatus.Healthy, healthCheckResult.Status);
     }
-    
+
     [Fact]
     public async Task ShouldReturnAppropriateResults()
     {
@@ -91,11 +97,11 @@ public async Task ShouldReturnAppropriateResults()
 
         // act
         var customActorHealthCheck =
-            configurationBuilder.HealthChecks.Values.Single(c => c.HealthCheck is DelegateHealthCheck);
-        
+            configurationBuilder.HealthChecks.Values.Single(c => c.Factory(Host.Services) is DelegateHealthCheck);
+
         var akkaHealthCheckContext = new AkkaHealthCheckContext(Sys)
             { Registration = customActorHealthCheck.ToHealthCheckRegistration() };
-        
+
         // should fail - target actor is not alive
         await InvokeHealthCheck(HealthStatus.Unhealthy);
 
@@ -105,7 +111,7 @@ public async Task ShouldReturnAppropriateResults()
 
         // should succeed - target actor is around
         await InvokeHealthCheck(HealthStatus.Healthy, 3000);
-        
+
         // kill the target actor
         await WatchAsync(fooActor);
         fooActor.Tell(PoisonPill.Instance);
@@ -118,10 +124,99 @@ public async Task ShouldReturnAppropriateResults()
         async Task InvokeHealthCheck(HealthStatus expectedStatus, int waitMilliseconds = 1)
         {
             using var fastCts = new CancellationTokenSource(TimeSpan.FromMilliseconds(waitMilliseconds));
-            var healthCheckResult = await customActorHealthCheck.HealthCheck.CheckHealthAsync(akkaHealthCheckContext, fastCts.Token);
-            if(healthCheckResult.Description != null)
+            var healthCheck = customActorHealthCheck.Factory(Host.Services);
+            var healthCheckResult = await healthCheck.CheckHealthAsync(akkaHealthCheckContext, fastCts.Token);
+            if (healthCheckResult.Description != null)
                 Output?.WriteLine(healthCheckResult.Description);
             Assert.Equal(expectedStatus, healthCheckResult.Status);
         }
     }
+
+    [Fact]
+    public async Task ShouldResolveDiHealthCheckFromContainer()
+    {
+        // arrange
+        var configurationBuilder = Host.Services.GetRequiredService<AkkaConfigurationBuilder>();
+
+        // act - add a DI-resolved health check to the existing configuration
+        configurationBuilder.WithHealthCheck<TestDiHealthCheck>("test-di-health");
+
+        // assert
+        Assert.Equal(3, configurationBuilder.HealthChecks.Count); // 2 from base configuration + 1 DI-resolved
+
+        // find the DI-resolved health check
+        var diHealthCheckRegistration =
+            configurationBuilder.HealthChecks.Values.Single(c => c.Name == "test-di-health");
+        var akkaHealthCheckContext = new AkkaHealthCheckContext(Sys)
+        {
+            Registration = diHealthCheckRegistration.ToHealthCheckRegistration()
+        };
+
+        // invoke the DI-resolved health check - TestDiHealthCheck is registered in ConfigureServices
+        var healthCheck = diHealthCheckRegistration.Factory(Host.Services);
+        var healthCheckResult = await healthCheck.CheckHealthAsync(akkaHealthCheckContext, CancellationToken.None);
+
+        // assert - health check should be healthy
+        Assert.Equal(HealthStatus.Healthy, healthCheckResult.Status);
+        Assert.Equal("Test DI health check is working with DI", healthCheckResult.Description);
+    }
+
+    [Fact]
+    public async Task ShouldResolveDiHealthCheckWithRegistrationTemplate()
+    {
+        // arrange
+        var configurationBuilder = Host.Services.GetRequiredService<AkkaConfigurationBuilder>();
+
+        // act - add a DI-resolved health check using the registration template pattern
+        configurationBuilder.WithHealthCheck<TestDiHealthCheck>(
+            "template-test",
+            HealthStatus.Degraded,
+            [
+                "custom", "test"
+            ]);
+
+        // assert
+        Assert.Equal(3, configurationBuilder.HealthChecks.Count); // 2 from base configuration + 1 DI-resolved
+
+        // find the DI-resolved health check
+        var diHealthCheckRegistration = configurationBuilder.HealthChecks.Values.Single(c => c.Name == "template-test");
+        Assert.Equal(HealthStatus.Degraded, diHealthCheckRegistration.FailureStatus);
+        Assert.Contains("custom", diHealthCheckRegistration.Tags);
+        Assert.Contains("test", diHealthCheckRegistration.Tags);
+
+        var akkaHealthCheckContext = new AkkaHealthCheckContext(Sys)
+            { Registration = diHealthCheckRegistration.ToHealthCheckRegistration() };
+
+        // invoke the health check
+        var healthCheck = diHealthCheckRegistration.Factory(Host.Services);
+        var healthCheckResult = await healthCheck.CheckHealthAsync(akkaHealthCheckContext, CancellationToken.None);
+
+        // assert
+        Assert.Equal(HealthStatus.Healthy, healthCheckResult.Status);
+        Assert.Equal("Test DI health check is working with DI", healthCheckResult.Description);
+    }
+
+    /// <summary>
+    /// Test health check class that requires DI (simulates ILogger dependency)
+    /// </summary>
+    private class TestDiHealthCheck : IAkkaHealthCheck
+    {
+        private readonly IServiceProvider? _serviceProvider;
+
+        public TestDiHealthCheck(IServiceProvider serviceProvider)
+        {
+            // Constructor with DI dependency
+            _serviceProvider = serviceProvider;
+        }
+
+        public Task<HealthCheckResult> CheckHealthAsync(AkkaHealthCheckContext context,
+            CancellationToken cancellationToken = default)
+        {
+            // Verify that dependencies can be resolved (simulates ILogger usage)
+            var hasServiceProvider = _serviceProvider != null;
+
+            return Task.FromResult(HealthCheckResult.Healthy("Test DI health check is working" +
+                                                             (hasServiceProvider ? " with DI" : "")));
+        }
+    }
 }

src/Akka.Hosting/AkkaConfigurationBuilder.cs

@@ -3,6 +3,7 @@
 using System.Collections.Immutable;
 using System.Linq;
 using System.Reflection;
+using System.Threading;
 using System.Threading.Tasks;
 using Akka.Actor;
 using Akka.Actor.Setup;
@@ -348,6 +349,31 @@ public AkkaConfigurationBuilder WithHealthCheck(AkkaHealthCheckRegistration regi
             return this;
         }
 
+        /// <summary>
+        /// Registers a DI-resolved health check with the <see cref="AkkaConfigurationBuilder"/>.
+        /// The health check type must be registered in the DI container.
+        /// </summary>
+        /// <param name="name">The healthcheck name.</param>
+        /// <param name="failureStatus">
+        /// The <see cref="HealthStatus"/> that should be reported upon failure of the health check. If the provided value
+        /// is <c>null</c>, then <see cref="HealthStatus.Unhealthy"/> will be reported.
+        /// </param>
+        /// <param name="tags">A list of tags that can be used for filtering health checks.</param>
+        /// <param name="timeout">An optional <see cref="TimeSpan"/> representing the timeout of the check.</param>
+        /// <typeparam name="T">The type of the health check that implements <see cref="IAkkaHealthCheck"/>.</typeparam>
+        /// <returns>The same <see cref="AkkaConfigurationBuilder"/> instance originally passed in.</returns>
+        public AkkaConfigurationBuilder WithHealthCheck<T>(string name, HealthStatus? failureStatus = null, 
+            IEnumerable<string>? tags = null, TimeSpan? timeout = null) where T : class, IAkkaHealthCheck
+        {
+            // Create a health check instance that will be resolved from DI when needed
+            var registration = new AkkaHealthCheckRegistration(name, GetServiceOrCreateInstance, failureStatus, tags, timeout);
+            
+            HealthChecks[registration.Name] = registration;
+            return this;
+            
+            static T GetServiceOrCreateInstance(IServiceProvider sp) => ActivatorUtilities.GetServiceOrCreateInstance<T>(sp);
+        }
+        
         internal void Bind()
         {
             // register as singleton - not interested in supporting multi-Sys use cases

src/Akka.Hosting/HealthChecks/AkkaHealthCheckExtensions.cs

@@ -17,7 +17,7 @@ public static HealthCheckRegistration ToHealthCheckRegistration(this AkkaHealthC
     {
         // func for lazily instantiating the health check registration
         Func<IServiceProvider, IHealthCheck> adapter = provider =>
-            new HealthCheckAdapter(registration.HealthCheck, provider.GetRequiredService<ActorSystem>());
+            new HealthCheckAdapter(registration.Factory(provider), provider.GetRequiredService<ActorSystem>());
 
         var tags = registration.Tags;
         tags.Add(AkkaTag);

src/Akka.Hosting/IAkkaHealthCheck.cs

@@ -16,7 +16,7 @@ namespace Akka.Hosting;
 /// </remarks>
 public sealed class AkkaHealthCheckRegistration
 {
-    private IAkkaHealthCheck _healthCheck;
+    private Func<IServiceProvider, IAkkaHealthCheck> _healthCheck;
     private string _name;
     private TimeSpan _timeout;
 
@@ -65,7 +65,42 @@ public AkkaHealthCheckRegistration(string name, IAkkaHealthCheck instance, Healt
         _name = name;
         FailureStatus = failureStatus ?? HealthStatus.Unhealthy;
         Tags = new HashSet<string>(tags ?? [], StringComparer.OrdinalIgnoreCase);
-        _healthCheck  = instance;
+        _healthCheck  = _ => instance;
+        Timeout = timeout ?? System.Threading.Timeout.InfiniteTimeSpan;
+    }
+
+    /// <summary>
+    /// Creates a new <see cref="AkkaHealthCheckRegistration"/> template for use with DI-resolved health checks.
+    /// This constructor is intended for use with generic health check registration methods.
+    /// </summary>
+    /// <param name="name">The healthcheck name.</param>
+    /// <param name="factory">The DI-enabled factory.</param>
+    /// <param name="failureStatus">
+    /// The <see cref="HealthStatus"/> that should be reported upon failure of the health check. If the provided value
+    /// is <c>null</c>, then <see cref="HealthStatus.Unhealthy"/> will be reported.
+    /// </param>
+    /// <param name="tags">A list of tags that can be used for filtering health checks.</param>
+    /// <param name="timeout">An optional <see cref="TimeSpan"/> representing the timeout of the check.</param>
+    /// <exception cref="ArgumentNullException">Thrown if <see cref="name"/> is null.</exception>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown if a negative timeout other than <see cref="System.Threading.Timeout.InfiniteTimeSpan"/> is used.</exception>
+    internal AkkaHealthCheckRegistration(string name, Func<IServiceProvider, IAkkaHealthCheck> factory, HealthStatus? failureStatus,
+        IEnumerable<string>? tags, TimeSpan? timeout)
+    {
+        if (name == null)
+        {
+            throw new ArgumentNullException(nameof(name));
+        }
+        if(factory == null) throw new ArgumentNullException(nameof(factory));
+
+        if (timeout <= TimeSpan.Zero && timeout != System.Threading.Timeout.InfiniteTimeSpan)
+        {
+            throw new ArgumentOutOfRangeException(nameof(timeout));
+        }
+
+        _name = name;
+        FailureStatus = failureStatus ?? HealthStatus.Unhealthy;
+        Tags = new HashSet<string>(tags ?? [], StringComparer.OrdinalIgnoreCase);
+        _healthCheck = factory;
         Timeout = timeout ?? System.Threading.Timeout.InfiniteTimeSpan;
     }
 
@@ -82,7 +117,7 @@ public string Name
     /// Gets or sets the <see cref="IAkkaHealthCheck"/>
     /// </summary>
     /// <exception cref="ArgumentNullException"></exception>
-    public IAkkaHealthCheck HealthCheck
+    public Func<IServiceProvider,IAkkaHealthCheck> Factory
     {
         get => _healthCheck;
         set => _healthCheck = value ?? throw new ArgumentNullException(nameof(value));

src/Examples/Akka.Hosting.Asp.LoggingDemo/Program.cs

@@ -7,6 +7,7 @@
 using Akka.Hosting.Asp.LoggingDemo;
 using Akka.Remote.Hosting;
 using Microsoft.AspNetCore.Diagnostics.HealthChecks;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
 using LogLevel = Akka.Event.LogLevel;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -34,8 +35,9 @@
             Roles = ["myRole"], 
             SeedNodes = ["akka.tcp://MyActorSystem@localhost:8110"]
         })
-        .WithActorSystemLivenessCheck()
         .WithAkkaClusterReadinessCheck()
+        .WithActorSystemLivenessCheck()
+        .WithHealthCheck<TestHealth>("di-test", HealthStatus.Unhealthy, new[] { "test", "custom" })
         .WithActors((system, registry) =>
         {
             var echo = system.ActorOf(act =>