How do I write a Wolverine global exception handler ?

[dfiordean]

I use Wolverine as a replacement for Mediatr in an ASP.NET core webapp

I have several commands that return values, and I use InvokeAsync to call the Wolverine handlers.

If there is an unhandled exception thrown by either handler, I want to log that exception.

Here is my Wolverine setup

        services.AddWolverine(options =>
        {
            options.Discovery.IncludeAssembly(Assembly.GetExecutingAssembly());
            //options.Policies.AddMiddleware<UnhandledExceptionMiddleware>();
            options.UseFluentValidation();
        });

I tried using a middleware (commented code), I can not achieve what I want

public class UnhandledExceptionMiddleware
{
    public static void Finally(ILogger<UnhandledExceptionMiddleware> logger, Envelope envelope)
    {
        if (envelope.Failure == null)
        {
            return;
        }

        logger.LogError(envelope.Failure, "Unhandled Exception for {MessageType}", envelope.MessageType);
    }
}

The only way I managed to have the unhandled exception logged is via a Configure() method in the handler

public static void Configure(HandlerChain chain) => chain.LogUnhandledException<MyHandler>();

and that LogUnhandledException is an extension method

public static void LogUnhandledException<T>(this HandlerChain chain)
    {
        chain.OnAnyException().CustomAction((runtime, lifecycle, exception) =>
                                            {
                                                var logger = runtime.Services.GetRequiredService<ILogger<T>>();
                                                logger.LogError(exception, "Unhandled Exception for {MessageType}", lifecycle.Envelope?.MessageType);
                                                throw exception;
                                            },
                                            "Unhandled exception",
                                            InvokeResult.Stop);
    }

However, writing that Configure() for every handler is quite verbose.

Isn't there a simpler way to configure this global exception handler ?

Thanks

[mohammadhoseindehghani]

Since you're using Wolverine as an in-process mediator through InvokeAsync, you might not need to implement custom middleware just for logging exceptions.

Wolverine has a built-in option for this:

services.AddWolverine(options =>
{
    options.InvokeTracing = InvokeTracingMode.Full;
});

With InvokeTracingMode.Full, Wolverine emits structured logs for inline invocations as well, including failed executions with the exception logged at Error level.

This is particularly useful when you're using Wolverine instead of MediatR, because you can get consistent logging without adding a Configure() method to every handler.

If you need additional custom logging or want to attach extra context to the log, then a global handler policy or middleware would make more sense.

I'd try the built-in tracing option first before adding another layer of custom middleware.