AspNetCore.Live.Api.HealthChecks.Client 1.2.0

LiveHealthChecks

Real-Time Api Health Check Monitoring

Packages	Version & Downloads
AspNetCore.Live.Api.HealthChecks.Server
AspNetCore.Live.Api.HealthChecks.Client

Background

An Asp Net Core Web Api has a Health Checks system built into it.

This project taps into that system & makes the generated Health Report,

available to Monitoring applications, in real-time.

The Client package, installed in the Api, runs the Health Check periodically,

and uploads the generated Health Report to the Server SignalR Hub.

The Hub sends a web socket push notification to the connected clients,

notifying them of the Health Report in real-time.

Server

You can use a Console app as a Health Checks Server.

Just create one with Web Sdk (project file):

<Project Sdk="Microsoft.NET.Sdk.Web">

Then, plug in the Server package.

var builder = WebApplication.CreateBuilder();

builder.Services.AddSignalR();
builder.Services.AddLiveHealthChecksServer(settings => settings.Clients = new ClientSettings[]
{
    new ClientSettings
    {
        ReceiveMethod = "SampleApiHealth",
        SecretKey = "43bf0968-17e0-4d22-816a-6eaadd766692"
    }
});

var app = builder.Build();

app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.MapHub<LiveHealthChecksHub>("/livehealthcheckshub");
});

app.Run();

A Client (Api) with a ReceiveMethod & SecretKey are set up in the Server.

The Api publishes to the Server with this information.

The Server sends push notification to the ReceiveMethod, if the Client's SecretKey matches.

Asp Net Core Api

In your Api add the Client Nuget package.

then

builder.Services.AddHealthChecks() //Required - add all your health checks
                .AddLiveHealthChecksClient(settings =>
                {
                    settings.HealthCheckIntervalInMinutes = 60;
                    settings.ReceiveMethod = "SampleApiHealth";
                    settings.HealthCheckServerHubUrl = "https://localhost:5001/livehealthcheckshub";
                    settings.SecretKey = "43bf0968-17e0-4d22-816a-6eaadd766692";
                    settings.PublishOnlyWhenNotHealthy = false;
                    //Optional - transform your health report to as you want it published.
                    settings.TransformHealthReport = healthReport => new
                    {
                        status = healthReport.Status.ToString(),
                        results = healthReport.Entries.Select(e => new
                        {
                            key = e.Key,
                            value = e.Value.Status.ToString()
                        })
                    };
                });

The ReceiveMethod is the SignalR method that Monitoring app needs to listen to.

The SecretKey must be the same between Server & Api.

Set PublishOnlyWhenNotHealthy to true if you want to publish anomalies,

ie those Health Reports with not Healthy status.

The Server sends the Health Report as a real-time push notification.

Note:- You can host a Server & Client in the same Api too.

Monitoring app

In your Monitoring app, create a SignalR connection to the Server Hub.

Then, start listening to the set ReceiveMethod ie "SampleApiHealth".

var connection = new HubConnectionBuilder()
                        .WithUrl("https://localhost:5001/livehealthcheckshub")
                        .WithAutomaticReconnect()
                        .Build();

connection.On("SampleApiHealth", new Type[] {typeof(object), typeof(object)},
    (arg1, arg2) =>
    {
        Console.WriteLine(arg1[0]);
        return Task.CompletedTask;
    }, new object());

await connection.StartAsync();

Live - Trigger & publish Health Checks

Besides, the Client package running the Health Check on the Api itself, periodically,

you can run a Health Check and publish the Health Report to the Server.

You can trigger a Health Check, at any point, from anywhere, in your API,

by injecting the built-in Health Check system's' HealthCheckService,

and calling the CheckHealthAsync method.

and then, publish the generated Health Report to the Server yourself,

by injecting the Client package's 'IMyHealthCheckPublisher interface and calling the Publish method.