DEV Community: Anton Ilin

ASP.NET health checks

Anton Ilin — Mon, 11 Oct 2021 13:12:17 +0000

Health check types

Sometimes you need to implement endpoint, which tells outside world if everything is OK with your application. For example you need to tell k8s that your application in unhealthy and let it restart pod.

There are 3 different types of health checks:

Startup - happens after your app is started.
Liveness - happens time to time after app is started and tells if it needs to be restarted.
Readiness - happens time to time after app is started and tells if it able to handle requests.

Startup and Liveness checks are the most important, so let's focus on them.

Any health check can be Dumb or Smart:

Dumb checks only indicate that app is not crushed and check as few as possible.
Smart checks indicate that app is working correctly and check as much as possible (db, service bus, storage connections).

And there is the rule: startup checks should be smart and readiness checks should be dumb. You don't want to check your db connection every 5 seconds and stop your container if connection is gone.

Implementation of dumb liveness check

Of course you can implement endpoint which always returns 200. But let's check what ASP.NET provides us!

To implement heals check you need to inherit from IHealthCheck interface:

public class LivenessHealthCheck : IHealthCheck
{
    public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
    {
        return Task.FromResult(HealthCheckResult.Healthy());
    }
}

This is very simple health check which always healthy. So it can be used as liveness check.

Now we need to register it in startup:

public void ConfigureServices(IServiceCollection services)
{
...
    services.AddHealthChecks()
        .AddCheck<LivenessHealthCheck>(LivenessHealthCheck.Name, tags: new[] { "liveness" })
...
}
...
public void Configure(IApplicationBuilder app, IHostApplicationLifetime appLifetime)
{
...
    app.UseEndpoints(endpoints => 
    { 
        endpoints.MapHealthChecks("/health", new HealthCheckOptions { Predicate = x => x.Tags.Contains("liveness") });});
        endpoints.MapControllers(); 
    });
...
}

So now we have /health which invoke all checks marked with tag "liveness". In our case it is LivenessHealthCheck which returns true if app is not crashed.

Implementation of smart startup check

To implement startup check we could do same as for liveness check - implement IHealthCheck.CheckHealthAsync method, check connections to required services and register them in startup. But it's already implemented!

Check this githab repository. It has implementation of most common checks. Everything you need is add required NuGet and register it in Startup!

public void ConfigureServices(IServiceCollection services)
{
...
    services.AddHealthChecks()
        .AddNpgSql(config.DbConnectionString, tags: new[] { "startup" })
        .AddAzureServiceBusTopic(config.MessageBusConnectionString, config.MessageBusTopic, tags: new[] { "startup" })
        .AddAzureBlobStorage(config.StorageConnectionString, tags: new[] { "startup" });
...
}
...
public void Configure(IApplicationBuilder app, IHostApplicationLifetime appLifetime)
{
...
    app.UseEndpoints(endpoints => 
    { 
        endpoints.MapHealthChecks("/health/startup", new HealthCheckOptions { Predicate = x => x.Tags.Contains("startup") });        
        endpoints.MapControllers(); 
    });
...
}

This code creates new "/health/startup" endpoint which returns 200 only if all 3 checks marked with "startup" tag (sql, service bus and blob) returns success.

GLHF

Testing of ASP.NET Core MVC apps using Microsoft Test Host

Anton Ilin — Wed, 28 Apr 2021 14:17:54 +0000

Automated testing is highly important. It helps not only to keep your code working after some changes but also makes easier the process of writing the code (TDD).

There are several approaches of testing ASP.NET Core MVC applications. The simplest one is just to create an instance of controller and call its methods in the test:

public class SomeControllerTests
{
    [Test]
    public async Task GetAll_ShouldReturnAll()
    {
        // Arrange
        var service = new SomeService();
        var controller = new SomeController(service);

        // Act
        var result = controller.GetAll();

        // Assert
        // TODO check result
    }
}

But this approach has several problems:

You need to create controller with all dependencies
You don't test HTTP part (routing, status codes, serialization)

These problems could be solved using Microsoft.AspNetCore.TestHost nuget.

public class TestFixture
{
    public HttpClient HttpClient { get; private set; }

    public async Task Initialize()
    {
        var builder = new HostBuilder()
            .ConfigureWebHost(webHost =>
            {
                webHost.UseTestServer();
                webHost.UseStartup<Startup>();
                ConfigureWebHost(webHost);
            });

        _host = await builder.StartAsync();
        HttpClient = _host.GetTestClient();
    }

    private void ConfigureWebHost(IWebHostBuilder builder)
    {
        IConfigurationRoot configurationRoot = null;
        builder.ConfigureAppConfiguration((context, conf) =>
        {
            conf.AddJsonFile("appsettings.json");
            configurationRoot = conf.Build();
        });

        builder.ConfigureTestServices(services =>
        {
            // Here you can overwrite some services
        });
    }
}

You also need a small class which will help to serialize request models:

public class JsonContent : ByteArrayContent
{
    public JsonContent(object obj) : base(ConvertToBytes(obj))
    {
        Headers.ContentType = new MediaTypeHeaderValue("application/json");
    }

    private static byte[] ConvertToBytes(object obj)
    {
        var serialized = JsonConvert.SerializeObject(obj);
        return Encoding.UTF8.GetBytes(serialized);
    }
}

Now you can create fake http host in your tests:

public class SomeControllersTests
{
    private TestFixture _sut;

    [SetUp]
    public async Task Setup()
    {
        _sut = new TestFixture();
        await _sut.Initialize();
    }

    [Test]
    public async Task GetAll_ShouldReturnAll()
    {
        // Act
        var request = new SomeRequest
        {
            // Some request data
        }

        var response = await _sut.HttpClient.PostAsync($"some-route", new JsonContent(request));

        // Assert
        // TODO check response
    }
}

Also you can add required authorization by manipulating with HttpClient.

GLHF

Building Linq predicates in code

Anton Ilin — Wed, 28 Apr 2021 10:35:38 +0000

Just imagine you have a class and each field of it represents a filter, which you need to apply to database entities, using Entity Framework or any other ORM:

public class Animal
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Height { get; set; }
    public int Weight { get; set; }
}

public class AnimalFilter
{
    public string Name { get; set; }
    public int? Height { get; set; }
    public int? Weight { get; set; }
}

First option would be just check if filter field has a value and create predicate for each case:

if (!string.IsNullOrWhiteSpace(filter.Name) && !filter.Height.HasValue && !filter.Weight.HasValue)
{
    var predicate = a => a.Name == filter.Name;
}
...

Disadvantage of this method is that you need to write custom predicates for all combinations of given parameters. For AnimalFilter it will be 8 different predicates. But what if filter has 10, 20 fields?

Another option is to use expressions. You can create expression based on a filter data and convert it to predicate:

var parameter = Expression.Parameter(typeof(Animal));
Expression expression = Expression.Constant(true);

if (!string.IsNullOrWhiteSpace(filter.Name))
{
    expression = Expression.AndAlso(
                    expression,
                    Expression.Equal(
                        Expression.Property(parameter, nameof(Animal.Name)),
                        Expression.Constant(filter.Name)
                    )
                )
}

if (filter.Height.HasValue))
{
    expression = Expression.AndAlso(
                    expression,
                    Expression.Equal(
                        Expression.Property(parameter, nameof(Animal.Height)),
                        Expression.Constant(filter.Height.Value)
                    )
                )
}

if (filter.Weight.HasValue))
{
    expression = Expression.AndAlso(
                    expression,
                    Expression.Equal(
                        Expression.Property(parameter, nameof(Animal.Weight)),
                        Expression.Constant(filter.Weight.Value)
                    )
                )
}

var predicate = Expression.Lambda<Func<Animal, bool>>(expression, parameter);

Advantage of this method is that for every new property added to the filter you need to add only one condition with code and do not create all combinations with existing properties.

This code can be improved by moving expression building to the helper class:

public static class PredicateExtensions
    {
        public static Expression And<T>(this Expression expression, ParameterExpression parameter, string propertyName, T value)
        {
            return Expression.AndAlso(
                    expression,
                    Expression.Equal(
                        Expression.Property(parameter, propertyName),
                        Expression.Constant(value)
                    )
                );
        }
}

Then this code is simplified to:

var parameter = Expression.Parameter(typeof(Animal));
Expression expression = Expression.Constant(true);

if (!string.IsNullOrWhiteSpace(filter.Name))
{
    expression = expression.And(parameter, nameof(Animal.Name), filter.Name);
}

if (filter.Height.HasValue))
{
    expression = expression.And(parameter, nameof(Animal.Height), filter.Height);
}

if (filter.Weight.HasValue))
{
    expression = expression.And(parameter, nameof(Animal.Weight), filter.Weight);
}

var predicate = Expression.Lambda<Func<Animal, bool>>(expression, parameter);

One problem that could occur - if your filter property and entity property have different types (for example, nullable and not nullable). In this case you need to add generic T parameter to the constant expression:

public static class PredicateExtensions
    {
        public static Expression And<T>(this Expression expression, ParameterExpression parameter, string propertyName, T value)
        {
            return Expression.AndAlso(
                    expression,
                    Expression.Equal(
                        Expression.Property(parameter, propertyName),
                        Expression.Constant(value, typeof(T))
                    )
                );
        }
}

GLHF

DEV Community: Anton Ilin

ASP.NET health checks

Health check types

Implementation of dumb liveness check

Implementation of smart startup check

Links

Testing of ASP.NET Core MVC apps using Microsoft Test Host

Links

Building Linq predicates in code