Introduction:

Health checks are an essential part of any application's health monitoring system. They are used to ensure that the application is functioning correctly, and if not, the issue can be addressed promptly. In this article, we will discuss how to implement health checks in .NET Core applications.

What are Health Checks?

Health checks are a set of tests that an application runs to ensure that it is functioning correctly. They are often used in production environments to ensure that an application is available and responding to requests. Health checks can be used to check the availability of critical dependencies, such as a database, a message broker, or other services that an application relies on.

Why are Health Checks important?

Health checks are essential for ensuring the uptime and reliability of an application. They provide an early warning system that can alert system administrators to issues before they become critical. Without health checks, it is difficult to determine the root cause of an issue, and it may take longer to resolve the problem.

Implementing Health Checks in .NET Core:

.NET Core provides an out-of-the-box health check framework that can be used to implement health checks. The framework includes several built-in checks, such as checking the status of the database connection, HTTP endpoints, and others. It also provides a mechanism to implement custom checks.

To implement a health check, we need to add the Microsoft.AspNetCore.Diagnostics.HealthChecks package to our project. This package contains the necessary components to add health checks to our application.

The following code snippet shows how to add the health check middleware to the application pipeline:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseHealthChecks("/health");
    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

In the above code snippet, we are adding the health check middleware to the application pipeline using the UseHealthChecks method. The method takes a path parameter that defines the endpoint for the health check. In this case, the health check endpoint is /health.

Once we have added the health check middleware to the application pipeline, we need to define the health check tests. To define a health check, we need to create an instance of the HealthCheck class and add it to the service collection.

The following code snippet shows how to define a health check that checks the status of the database connection:

services.AddHealthChecks()
    .AddSqlServer(Configuration.GetConnectionString("DefaultConnection"));

In the above code snippet, we are adding a health check that checks the status of the database connection. The AddSqlServer method takes the connection string as a parameter and returns a SqlServerHealthCheckBuilder instance. The SqlServerHealthCheckBuilder class provides several methods to configure the health check.

The health check framework provides several built-in checks that can be used to monitor the health of the application. These checks include:

• AddApplicationInsightsPublisher: Adds a health check that publishes the results to Application Insights.
• AddDiskStorageHealthCheck: Adds a health check that checks the available disk space.
• AddMemoryHealthCheck: Adds a health check that checks the available memory.
• AddProcessAllocatedMemoryHealthCheck: Adds a health check that checks the allocated memory of the process.

Custom Health Checks:

In addition to the built-in health checks, we can also implement custom health checks. Custom health checks can be used to check the availability of specific dependencies or services that are not included in the built-in health checks.

To implement a custom health check, we need to create a class that implements the IHealthCheck interface. The interface has a single method named CheckAsync that returns a HealthCheckResult instance.

The following code snippet shows an example of a custom health check that checks the availability of an external API:

public class ExternalApiHealthCheck : IHealthCheck
{
    private readonly HttpClient _httpClient;

    public ExternalApiHealthCheck(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<HealthCheckResult> CheckAsync(CancellationToken cancellationToken = default)
    {
        try
        {
            var response = await _httpClient.GetAsync("https://external-api.com/status", cancellationToken);

            if (response.IsSuccessStatusCode)
            {
                return HealthCheckResult.Healthy();
            }
            else
            {
                return HealthCheckResult.Unhealthy();
            }
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex);
        }
    }
}

In the above code snippet, we are creating a custom health check that checks the availability of an external API. The class implements the IHealthCheck interface and has a constructor that takes an instance of the HttpClient class. The CheckAsync method sends a GET request to the external API's status endpoint and returns a HealthCheckResult instance based on the response.

To add the custom health check to the service collection, we need to call the AddCheck method on the HealthChecksBuilder instance:

services.AddHealthChecks()
    .AddCheck<ExternalApiHealthCheck>("external_api");

In the above code snippet, we are adding the custom health check to the service collection using the AddCheck method. The method takes the name of the health check and an instance of the health check class as parameters.

Conclusion:

Health checks are an essential part of any application's health monitoring system. They provide an early warning system that can alert system administrators to issues before they become critical. In this article, we discussed how to implement health checks in .NET Core applications using the built-in health check framework. We also discussed how to implement custom health checks to monitor specific dependencies or services.

Implementing health checks can help improve the uptime and reliability of your application. By monitoring the health of your application and its dependencies, you can ensure that your application is always available and functioning correctly.