Health Monitoring In ASP.NET Core

The dream of every software engineer is to write a code in such a way that there won’t be any defects and none of the infrastructure will ever go down. But, that is not the case in the real world and with the Microservices architecture it has become even more difficult to identify the state of the container.

In fact, we need a mechanism in place to quickly identify and fix the issue at the earliest unless it turns out to be a bigger problem. This is where Health Monitoring comes into picture.

Health Monitoring in ASP.NET Core allows you to get near real-time state of the container. These monitoring mechanisms are handy when your application is dealing with components such as database, cache, url, message broker etc.

Implementing basic health monitoring

When developing ASP.NET Core Microservices, you can use a built-in health monitoring feature by using a nuget package Microsoft.Extension.Diagnostic.HealthCheck. These health monitoring features can be enabled by using a set of services and middleware.

public void ConfigureServices
(IServiceCollection services)
{
services.AddControllers();
services.AddHealthChecks();
}
public void Configure(IApplicationBuilder app,
IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.MapHealthChecks("/api/health");
}
}

When you run the application, you will see the output as Healthy

For two lines of code, not too bad. However, we can do much better.

Returning status in JSON format

By default, the output of the health monitoring is in “plain/text”. Therefore, we can see the health status as Healthy or UnHealthy. In order to see the detailed output with all the dependencies, the application has to be customized with “ResponseWriter” property which is available in AspNetCore.HealthChecks.UI.Client

Firstly, add the nuget package

dotnet add package AspNetCore.HealthChecks.UI
dotnet add package AspNetCore.HealthChecks.UI.Client

Now, let’s configure the application

endpoints.MapHealthChecks("/api/health",
new HealthCheckOptions()
{
Predicate = _ => true,
ResponseWriter = UIResponseWriter.
WriteHealthCheckUIResponse
});

Now, run the application and you will see the output in json format

{
"status": "Healthy",
"totalDuration": "00:00:00.0038176"
}

Health Status for URI’s

You can easily verify the status of the endpoints/uri’s by using nuget package

dotnet add package AspNetCore.HealthChecks.uris

Now, let's modify our code to accommodate the uri’s

public void ConfigureServices
(IServiceCollection services)
{
services.AddControllers();
services.AddHealthChecks()
.AddUrlGroup(new Uri
("https://localhost:5001/weatherforecast"),
name: "base URL", failureStatus:
HealthStatus.Degraded)
}

You need to use AddUrlGroup method to verify the uri’s and in case of failure, the status of the url will be displayed as Degraded.

Now, run the application and the output will look similar.

{
"status": "Healthy",
"totalDuration": "00:00:00.1039166",
"entries": {
"base URL": {
"data": {},
"duration": "00:00:00.0904980",
"status": "Healthy",
"tags": []
}
}

Health Status for SQL Server

In order to verify the status of SQL Server database, I did database installation in docker; however, you can use local instance of database server.

You can install SQL Server in docker using below commands

//Docker pull command to install
docker pull mcr.microsoft.com/mssql/server
//Docker Run command
docker run --privileged -e 'ACCEPT_EULA=Y'
-e 'SA_PASSWORD=Winter2019' -p 1433:1433
--name=MSSQL -d
mcr.microsoft.com/mssql/server:latest

Once the database is up and running, add the below nuget package.

dotnet add package AspNetCore.HealthChecks.SqlServer
public void ConfigureServices
(IServiceCollection services)
{
services.AddControllers();
services.AddHealthChecks()
.AddUrlGroup(new Uri("https://localhost:5001/weatherforecast"), name: "base URL", failureStatus: HealthStatus.Degraded) .AddSqlServer(Configuration.GetConnectionString("DefaultConnection"),
healthQuery: "select 1",
failureStatus: HealthStatus.Degraded,
name: "SQL Server");
}

Note

In the HealthQuery, don’t use any fancy queries to verify the Database connection. The main purpose of using “Select 1” is that it takes less execution time.

Now run the application and your output will look similiar.

{
"status": "Healthy",
"totalDuration": "00:00:00.1039166",
"entries": {
"base URL": {
"data": {},
"duration": "00:00:00.0904980",
"status": "Healthy",
"tags": []
},
"SQL Server": {
"data": {},
"duration": "00:00:00.0517363",
"status": "Healthy",
"tags": []
}
}
}

Custom Health Check

Custom Health Check can be easily implemented by using IHealthCheck interface.

public class TodoHealthCheck : IHealthCheck
{
public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
//Implement you logic here
var healthy = true;
if (healthy)
return Task.FromResult(HealthCheckResult.Healthy());
return Task.FromResult(HealthCheckResult.Unhealthy());
}
}

The AddCheck method in Configure services is used to add health check with the specified name.

public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddHealthChecks()
.AddUrlGroup(new Uri("https://localhost:5001/weatherforecast"), name: "base URL", failureStatus: HealthStatus.Degraded)
.AddSqlServer(Configuration.GetConnectionString("DefaultConnection"),
healthQuery: "select 1",
failureStatus: HealthStatus.Degraded,
name: "SQL Server")
.AddCheck<TodoHealthCheck>("Todo Health Check",failureStatus:HealthStatus.Unhealthy);
}

Now, run the application

{
"status": "Healthy",
"totalDuration": "00:00:00.0544065",
"entries": {
"base URL": {
"data": {},
"duration": "00:00:00.0527285",
"status": "Healthy",
"tags": []
},
"SQL Server": {
"data": {},
"duration": "00:00:00.0386450",
"status": "Healthy",
"tags": []
},
"Todo Health Check": {
"data": {},
"duration": "00:00:00.0001681",
"status": "Healthy",
"tags": []
}
}
}

Let’s visualize.

Display the output in the JSON format looks reasonable; however, visualizing the UI makes more sense and can be easily understandable for non-technical background people as well.

Add nuget package.

dotnet add package AspNetCore.HealthChecks.UI.InMemory.Storage

To visualize the UI health check, you need to amend changes in services and middleware.

public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddHealthChecks()
.AddUrlGroup(new Uri("https://localhost:5001/weatherforecast"), name: "base URL", failureStatus: HealthStatus.Degraded)
.AddSqlServer(Configuration.GetConnectionString("DefaultConnection"),
healthQuery: "select 1",
failureStatus: HealthStatus.Degraded,
name: "SQL Server")
.AddCheck<TodoHealthCheck>("Todo Health Check",failureStatus:HealthStatus.Unhealthy);
services.AddHealthChecksUI(opt =>
{
opt.SetEvaluationTimeInSeconds(10); //time in seconds between check
opt.MaximumHistoryEntriesPerEndpoint(60); //maximum history of checks
opt.SetApiMaxActiveRequests(1); //api requests concurrency
opt.AddHealthCheckEndpoint("default api", "/api/health"); //map health check api
})
.AddInMemoryStorage();
}

The Health Check UI endpoint comes by default as “/healthchecks-ui“. You can change this value by customizing it through the MapHealthCheckUI method.

In the code, I have set the polling interval as 10 seconds. It checks whether all the endpoints/databases etc within the application are working as expected.

Now run the application.

Now, let’s stop the SQL Server from Docker container and verify the output

//Get Container ID
docker ps
//Stop Docker container for SQL Server
docker stop <Container Id here>

Other Health checksFeatures.

Health Monitoring is not limited to SQL Server and URI’s. However, it supports a large number of features and details can be found here

Conclusion

In Microservices or container based architecture, it’s a must to include to health monitoring, and without this feature, life will be miserable. With this health monitoring feature, you and your team can act upon the health of your services in a robust and standardized way.

Asp.Net Core team has added top notch support for health checks, and made it effortless for developers to build and customize.

Cheers!

I hope you like the article. In case you found the article as interesting then kindly like and share it.