C#•2y ago

Warning CA1848 : For improved performance, use the LoggerMessage delegates...

Can someone show me how implement LoggerMessage into here? My brain is not connecting the dots:

public class ExceptionFilterMiddleware
{
    private readonly ILogger<ExceptionFilterMiddleware> _logger;
    private readonly RequestDelegate _next;

    public ExceptionFilterMiddleware(ILogger<ExceptionFilterMiddleware> logger, RequestDelegate next)
    {
        _logger = logger;
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError("An exception occurred processing the request: {ex}", ex); <-- rule violation here
            context.Response.ContentType = MediaTypeNames.Application.Json;
            context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;

            var json = JsonSerializer.Serialize(new { Message = ex.Message }, context.RequestServices.GetRequiredService<JsonSerializerOptions>());
            await context.Response.WriteAsync(json);
        }
    }
}

public class ExceptionFilterMiddleware
{
    private readonly ILogger<ExceptionFilterMiddleware> _logger;
    private readonly RequestDelegate _next;

    public ExceptionFilterMiddleware(ILogger<ExceptionFilterMiddleware> logger, RequestDelegate next)
    {
        _logger = logger;
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError("An exception occurred processing the request: {ex}", ex); <-- rule violation here
            context.Response.ContentType = MediaTypeNames.Application.Json;
            context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;

            var json = JsonSerializer.Serialize(new { Message = ex.Message }, context.RequestServices.GetRequiredService<JsonSerializerOptions>());
            await context.Response.WriteAsync(json);
        }
    }
}

public class ExceptionFilterMiddleware
{
    private readonly ILogger<ExceptionFilterMiddleware> _logger;
    private readonly RequestDelegate _next;

    public ExceptionFilterMiddleware(ILogger<ExceptionFilterMiddleware> logger, RequestDelegate next)
    {
        _logger = logger;
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError("An exception occurred processing the request: {ex}", ex); <-- rule violation here
            context.Response.ContentType = MediaTypeNames.Application.Json;
            context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;

            var json = JsonSerializer.Serialize(new { Message = ex.Message }, context.RequestServices.GetRequiredService<JsonSerializerOptions>());
            await context.Response.WriteAsync(json);
        }
    }
}

public class ExceptionFilterMiddleware
{
    private readonly ILogger<ExceptionFilterMiddleware> _logger;
    private readonly RequestDelegate _next;

    public ExceptionFilterMiddleware(ILogger<ExceptionFilterMiddleware> logger, RequestDelegate next)
    {
        _logger = logger;
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError("An exception occurred processing the request: {ex}", ex); <-- rule violation here
            context.Response.ContentType = MediaTypeNames.Application.Json;
            context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;

            var json = JsonSerializer.Serialize(new { Message = ex.Message }, context.RequestServices.GetRequiredService<JsonSerializerOptions>());
            await context.Response.WriteAsync(json);
        }
    }
}

Andrew•3/26/24, 6:36 PM

This SO kind of explains it https://stackoverflow.com/questions/75893617/loggermessage-structured-logging

Basically you're paying an up front cost once to parse the template.

Stack Overflow

LoggerMessage structured logging

I'm using LoggerMessage logging in my application. I want to use structured logging like below. But I don't see a way. Is this possible in LoggerMessage ?
logger.LogInformation("Test {id}"...

Andrew•3/26/24, 6:40 PM

There's also caveats, because improvements have been made in this area with https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/interpolated-string-handler

So if you're using a newer logging library hopefully it has interpolated string handlers and you can just use those

Explore string interpolation handlers - C#

This advanced tutorial shows how you can write a custom string interpolation handler that hooks into the runtime processing of an interpolated string.

MangoOP•3/26/24, 6:52 PM

So it sounds like you don’t have to implement that if you don’t want to

Andrew•3/26/24, 6:57 PM

nope, up to the logging library. LoggerMessage will always keep the efficiency

Andrew•3/26/24, 6:57 PM

It's more verbose though

MangoOP•3/26/24, 6:58 PM

Looks like you lose the string interpolation though

Andrew•3/26/24, 6:58 PM

"An exception occurred processing the request: {ex}""An exception occurred processing the request: {ex}" is a formatted string

Andrew•3/26/24, 6:59 PM

$"An exception occurred processing the request: {ex}"$"An exception occurred processing the request: {ex}" would be the string interpolation form of that

MangoOP•3/26/24, 6:59 PM

I meant the ability to pass in the argument as values too

MangoOP•3/26/24, 7:00 PM

Maybe I’m using the wrong overload for Error

MangoOP•3/26/24, 7:04 PM

I want to log an error with a preamble and the exception itself

Andrew•3/26/24, 7:04 PM

not really, I think LoggerMessage is a little bit harder to understand. The attribute form is a bit easier to think about because it just becomes a method call

Andrew•3/26/24, 7:04 PM

https://learn.microsoft.com/en-us/dotnet/core/extensions/logger-message-generator

Compile-time logging source generation - .NET

Learn how to use the LoggerMessageAttribute and compile-time source generation for logging in .NET.

Andrew•3/26/24, 7:06 PM

but at the end of the day, it's a perf problem. If you're not in a tight loop and the extra string allocation isn't a problem then just don't worry about it

MangoOP•3/26/24, 7:08 PM

Yeah it’s in a part of a code I would hope doesn’t ever get called

MangoOP•3/26/24, 7:09 PM

If it does it would be as little as possible

MangoOP•3/26/24, 7:09 PM

I’m not logging in an iteration

MangoOP•3/26/24, 7:09 PM

I’ll mute that warning and file it under “things to try later”

MangoOP•3/27/24, 3:14 PM

So what’s a good use case for high performance logging?

MangoOP•3/27/24, 3:15 PM

Operations where logging is the primary IO?

MangoOP•3/27/24, 3:15 PM

Which seems odd

Andrew•3/27/24, 9:24 PM

any logging in a tight loop

Warning CA1848 : For improved performance, use the LoggerMessage delegates...

Similar Threads

Similar Threads

Similar Threads