`DbContextCheck` should work together with `IDbContextFactory`

[meggima]

Is your feature request related to a problem? Please describe.

We use the services.AddDbContextCheck<AppDbContext>() method to monitor the connection to the database in our apps. Due to performance reasons we switched to using IDbContextFactory to access instances of EF Core DbContext:

services.AddPooledDbContextFactory<AppDbContext>(dbContextOptions)

When we did so, we noticed that the DbContextHealthCheck does not support the factory and, thus, we had to register the DbContext directly to keep the HealthCheck working:

// This is just required for the HealthCheck, since it does not (yet?) work with the Factory.
services.AddDbContextPool<AppDbContext>(dbContextOptions);

Describe the solution you'd like

The DbContextHealthCheck should support IDbContextFactory without any additional service registrations.

Additional context

We are willing to invest some time to implement this and submit a pull request. But we need some support on how we should implement this and how the API should look like.

We've moved this issue to the Backlog milestone. This means that it is not going to be worked on for the coming release. We will reassess the backlog following the current release and consider this item at that time. To learn more about our issue management process and to have better expectation regarding different types of issues you can read our Triage Process.

[mwasson74]

Can a "help-wanted" label be added to this? I just implemented a class similar to the DbContextHealthCheck that gets a IDbContextFactory<TContext> injected in the constructor. I called the class PooledDbContextHealthCheck but there may be a way to have DbContextHealthCheck seamlessly handle both.

Looking forward to submitting a PR for this but don't want to step on anyone's toes!!

[Willimaendu]

Any news about this? Shouldn't be a big thing to implement a health check which injects IDbContextFactory instead.

[Tak1za]

Anyone who stumbles across this you can add a custom health check like this:

namespace my_service
{
    using Microsoft.EntityFrameworkCore;
    using Microsoft.Extensions.Diagnostics.HealthChecks;
    using Microsoft.Extensions.Options;
    using System.Threading.Tasks;
    using System.Threading;
    using System;
    using System.Diagnostics.CodeAnalysis;

    // Custom health check for IDbContextFactory<TContext> to check if the database is reachable
    // The default DbContextHealthCheck provided by Microsoft does not work with IDbContextFactory
    // as raised in this issue here: https://github.com/dotnet/aspnetcore/issues/33344
    // This class consumes an IDbContextFactory and implements the same method that DbContextHealthCheck does

    [ExcludeFromCodeCoverage]
    internal sealed class MyDbContextHealthCheckOptions<TContext> where TContext : DbContext
    {
        public Func<TContext, CancellationToken, Task<bool>>? CustomTestQuery { get; set; }
    }

    [ExcludeFromCodeCoverage]
    internal sealed class MyDbContextHealthCheck<TContext> : IHealthCheck where TContext : DbContext
    {
        private static readonly Func<TContext, CancellationToken, Task<bool>> DefaultTestQuery = (TContext dbContext, CancellationToken cancellationToken) => dbContext.Database.CanConnectAsync(cancellationToken);

        private readonly TContext _dbContext;

        private readonly IOptionsMonitor<MyDbContextHealthCheckOptions<TContext>> _options;

        public MyDbContextHealthCheck(IDbContextFactory<TContext> dbContextFactory, IOptionsMonitor<MyDbContextHealthCheckOptions<TContext>> options)
        {
            ArgumentNullException.ThrowIfNull(dbContextFactory, nameof(dbContextFactory));
            ArgumentNullException.ThrowIfNull(options, nameof(options));
            _dbContext = dbContextFactory.CreateDbContext();
            _options = options;
        }

        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
        {
            ArgumentNullException.ThrowIfNull(context, nameof(context));
            Func<TContext, CancellationToken, Task<bool>> func = _options.Get(context.Registration.Name).CustomTestQuery ?? DefaultTestQuery;
            try
            {
                if (await func(_dbContext, cancellationToken))
                {
                    return HealthCheckResult.Healthy();
                }

                return new HealthCheckResult(context.Registration.FailureStatus);
            }
            catch (Exception ex)
            {
                return HealthCheckResult.Unhealthy(ex.Message, ex);
            }
            finally
            {
                await _dbContext.DisposeAsync();
            }
        }
    }
}

And then use it in your Program.cs/Startup.cs as below:

builder.Services
    .AddHealthChecks()
    .AddCheck<HealthCheck>("Health Check")
    .AddCheck<MyDbContextHealthCheck<MyDbContext>>("DB Check");