Logging in the middleware exception handler

Question

In a layered web application I want to move all error logging from the Domain and Data layers to the global exception handler, but I'm not sure what is the trade-off. I want to remove any logging call and replace it by a more specific Exception (custom if it's necessary) or remove the catching:

try{
   . . . 
}
catch
{
   Logger.Error('Info'); // <-- remove this for a: throw new CustomException('Info', ex);
   throw;                // <-- then, remove this line
}

There is a configured Global Exception Handler as middle-ware in the WebAPI, then as part of the handler method I'm going to log any exception occurred

// Startup.cs
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseExceptionHandler(
    error =>
    {
        GlobalExceptionHandler.ErrorHandling(error, env);
    });
}

// GlobalExceptionHandler.cs
public static class GlobalExceptionHandler
{
    public static void ErrorHandling(IApplicationBuilder errorApp, IHostingEnvironment env)
    {
        errorApp.Run(async context =>
        {
            .
            .
            .

            Log.Current.Error(exception.Message, () => exception);
        }
    }
}

Could be a better approach to avoid duplicated logging records?

Moving exception logging out of classes and into middleware or interceptors is good practice. If a method catches an exception, logs it, and rethrows it, then an AOP approach lets the you eliminate all those try/catches and let something outside the class handle it. Once in a while you may still need logging in a class, like in scenarios where the class actually handles an exception and does something to account for it, but you still want to log something so you know the exception happened. — Scott Hannen
– Scott Hannen, Commented May 2, 2019 at 15:43

Francesco D.M. · Accepted Answer · 2019-05-02 15:50:50Z

In the applications I build I like to use the approach you are suggesting. I'll post the middleware that I use:

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using MyProject.Interfaces;

namespace MyProject.Middlewares
{
    public class ErrorReporterMiddleware
    {
        private readonly RequestDelegate RequestDelegate;

        public ErrorReporterMiddleware(RequestDelegate requestDelegate)
        {
            RequestDelegate = requestDelegate ?? throw new ArgumentNullException(nameof(requestDelegate));
        }

        public async Task Invoke(HttpContext httpContext, IErrorReporter errorReporter)
        {
            try
            {
                await RequestDelegate(httpContext);
            }
            catch (Exception e)
            {
                await errorReporter?.CaptureAsync(e);
                throw;
            }
        }
    }
}

In this case IErrorReporter is an interface I have defined in the MyProject.Interfaces namespace. I use it to abstract the logging service:

using System;
using System.Threading.Tasks;

namespace MyProject.Interfaces
{
    public interface IErrorReporter
    {
        Task CaptureAsync(Exception exception);
        Task CaptureAsync(string message);
    }
}

Then in the Startup.cs I just add the following line to the Configure method:

app.UseMiddleware<ErrorReporterMiddleware>();

Nothing special but I think it's a clean approach.

Collectives™ on Stack Overflow

Logging in the middleware exception handler

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related