Unhandled Exception Global Handler for OWIN / Kata

Question

What is the proper way to implement a global Exception catcher-handler in a Katana (OWIN) implementation?

In a self-hosted OWIN/Katana implementation running as an Azure Cloud Service (worker role), I placed this code in a Middleware:

throw new Exception("pooo");

Then I placed this code in the Startup class Configuration method, setting a breakpoint in the event handler:

 AppDomain.CurrentDomain.UnhandledException += 
    CurrentDomain_UnhandledExceptionEventHandler;

and the event handler in the same class (with a breakpoint set on the first line):

private static void CurrentDomain_UnhandledExceptionEventHandler(object sender, UnhandledExceptionEventArgs e)
{
    var exception = (Exception)e.ExceptionObject;
    Trace.WriteLine(exception.Message);
    Trace.WriteLine(exception.StackTrace);
    Trace.WriteLine(exception.InnerException.Message);
}

When the code runs the breakpoint is not hit. The Visual Studio Output window does include this however:

A first chance exception of type 'System.Exception' occurred in redacted.dll
A first chance exception of type 'System.Exception' occurred in mscorlib.dll

I also tried moving the wireup and handler to the Worker Role OnStart method but still the breakpoint is not hit.

I am not using WebAPI at all, but did look at posts on what is done there, but I found nothing clear, so here I am.

Running on .NET Framework 4.5.2, VS 2013.

All ideas appreciated. Thanks.

Answer 1

Try writing a custom middleware and placing it as the first middleware:

public class GlobalExceptionMiddleware : OwinMiddleware
{
   public GlobalExceptionMiddleware(OwinMiddleware next) : base(next)
   {}

   public override async Task Invoke(IOwinContext context)
   {
      try
      {
          await Next.Invoke(context);
      }
      catch(Exception ex)
      {
          // your handling logic
      }
   }
 }

Place it as the first middleware:

public class Startup
{
    public void Configuration(IAppBuilder builder)
    {
        var config = new HttpConfiguration();

        builder.Use<GlobalExceptionMiddleware>();
        //register other middlewares
    }
}

When we register this middleware as the first middle, any exceptions happening in other middlewares (down the stacktrace) will propagate up and be caught by the try/catch block of this middleware.

It's not mandatory to always register it as the first middleware, in case you don't need global exception handling for some middlewares, just register these middlewares before this one.

public class Startup
{
    public void Configuration(IAppBuilder builder)
    {
        var config = new HttpConfiguration();

        //register middlewares that don't need global exception handling. 
        builder.Use<GlobalExceptionMiddleware>();
        //register other middlewares
    }
}

Answer 2

Try this:

public class CustomExceptionHandler : IExceptionHandler
{    
    public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
    {
      // Perform some form of logging

      context.Result = new ResponseMessageResult(new HttpResponseMessage
      {
        Content = new StringContent("An unexpected error occurred"),
        StatusCode = HttpStatusCode.InternalServerError
      });

      return Task.FromResult(0);
    }
}

And at startup:

public void Configuration(IAppBuilder app)
{
  var config = new HttpConfiguration();

  config.Services.Replace(typeof(IExceptionHandler), new CustomExceptionHandler());
}

Answer 3

@Khanh TO's answer is excellent; Nice terse code, and well explained.

It was not working for me. I added a test exception to one of my .NET MVC controllers like this:

throw new Exception("Test GlobalExceptionMiddleware");

The exception was not caught in the Invoke method.

This is very easy to debug:

1. Put a breakpoint on the test exception.
2. Hit F10 or step over each line until you get to the code that is handling the exception.

For me, there was code added to a BaseController overriding OnException. This code was handling the exception and not rethrowing. I hope this is a helpful addendum to @Khanh TO's answer.

Update

OK, I realize this question is tagged with Web API, and my use case is .NET MVC, but I found this question on a search for Owin middleware. When I debug my solution with the test exception, and watch $exception in the Locals view, the exception is gone when I get back to the Owin middleware. Therefore I have not used the code in @Khanh TO's answer. Instead I have added try/catch blocks to my Startup and Global.asax. I have also OnException in my base controller like this:

protected override void OnException(ExceptionContext filterContext)
{
    if (filterContext.ExceptionHandled)
    {
        return;
    }
    var e = filterContext.Exception;
    Log.Error("BaseController.OnException caught exception:", e);
    filterContext.ExceptionHandled = true;
}

This answer will catch any exceptions on application start up and any exception in a controller. That is enough for my needs.

Answer 4

You can use custom exception filter attributes.

public static class WebApiConfiguration
{
    public static void Register(HttpConfiguration config)
    {
        config.RegisterExceptionFilters();
    }
}

public static class HttpConfigurationFilterExtensions
{
    public static HttpConfiguration RegisterExceptionFilters(this HttpConfiguration httpConfig)
    {
        httpConfig.Filters.Add(new CustomExceptionFilterAttribute());

        return httpConfig;
    }
}

public class CustomExceptionFilterAttribute : ExceptionFilterAttribute
{
    public override void OnException(HttpActionExecutedContext context)
    {
        if (context.Exception is CustomException)
        {
            context.Response = new HttpResponseMessage((HttpStatusCode)CustomHttpStatusCode.CustomCode);
        }
    }
}

public class CustomException : Exception
{
    public CustomException(string message)
        : base(message)
    {
    }
}