Logging-Generator should allow to skip the IsEnabled check

[gfoidl]

Taking the example from #45290 and bring it to the logging-generator:

public class Connection
{
    private string? _connectionId;
    public string ConnectionId => _connectionId ??= GenerateConnectionId();

    private string GenerateConnectionId() => Guid.NewGuid().ToString();    // or something more expensive
}

public static partial class Log
{
    public static void ConnectionStarted(this ILogger logger, Connection connection)
    {
        if (logger.IsEnabled(LogLevel.Debug))
        {
            ConnectionStarted(logger, connection.ConnectionId);
        }
    }

    [LoggerMessage(EventId = 1, EventName = "ConnectionStarted", Level = LogLevel.Debug, Message = "Connection {ConnectionId} started")]
    private static partial void ConnectionStarted(this ILogger logger, string connectionId);
}

The key-point of the logger.IsEnabled check is to avoid the creation of a expensive resource if not needed.

The generated code looks like (simplifyed some names, to make it easiert to read):

partial class Log
{
    private static readonly Action<ILogger, string, Exception?> __ConnectionStartedCallback =
        LoggerMessage.Define<string>(LogLevel.Debug, new EventId(1, "ConnectionStarted"), "Connection {ConnectionId} started", true);

    private static partial void ConnectionStarted(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.String connectionId)
    {
        if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
        {
            __ConnectionStartedCallback(logger, connectionId, null);
        }
    }
}

So in LoggerMessage.Define true is passed in to skip the IsEnabled-check, which is good.
But in the "logging method" IsEnabled is checked, regardless if our code already checked it.

Note: the IsEnabled check isn't free either, I'll defer to @davidfowl's comment: #50334 (comment)

Thus I propose to extend

[AttributeUsage(AttributeTargets.Method)]
public sealed class LoggerMessageAttribute : Attribute
{
    public LoggerMessageAttribute() { }
    public int EventId { get; set; } = -1;
    public string? EventName { get; set; }
    public LogLevel Level { get; set; } = LogLevel.None;
    public string Message { get; set; } = "";
+   public bool SkipEnabledCheck { get; set; } = false;
}

so the above example could be written as:

public static partial class Log
{
    // ...

    [LoggerMessage(EventId = 1, EventName = "ConnectionStarted", Level = LogLevel.Debug, Message = "Connection {ConnectionId} started", SkipEnabledCheck = true)]
    private static partial void ConnectionStarted(this ILogger logger, string connectionId);
}

and the generated code to be like:

partial class Log
{
    private static readonly Action<ILogger, string, Exception?> __ConnectionStartedCallback =
        LoggerMessage.Define<string>(LogLevel.Debug, new EventId(1, "ConnectionStarted"), "Connection {ConnectionId} started", true);

    private static partial void ConnectionStarted(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.String connectionId)
    {
        __ConnectionStartedCallback(logger, connectionId, null);
    }
}

That way IsEnabled is checked only once, if the user is aware of that pattern and opts-into this behaviour.

/cc: @maryamariyan

---

PS: should this be a formal api proposal? I didn't chose that template, as this api isn't shipped public

Tagging subscribers to this area: @maryamariyan
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Taking the example from #45290 and bring it to the logging-generator:

public class Connection
{
    private string? _connectionId;
    public string ConnectionId => _connectionId ??= GenerateConnectionId();

    private string GenerateConnectionId() => Guid.NewGuid().ToString();    // or something more expensive
}

public static partial class Log
{
    public static void ConnectionStarted(this ILogger logger, Connection connection)
    {
        if (logger.IsEnabled(LogLevel.Debug))
        {
            ConnectionStarted(logger, connection.ConnectionId);
        }
    }

    [LoggerMessage(EventId = 1, EventName = "ConnectionStarted", Level = LogLevel.Debug, Message = "Connection {ConnectionId} started")]
    private static partial void ConnectionStarted(this ILogger logger, string connectionId);
}

The key-point of the logger.IsEnabled check is to avoid the creation of a expensive resource if not needed.

The generated code looks like (simplifyed some names, to make it easiert to read):

partial class Log
{
    private static readonly Action<ILogger, string, Exception?> __ConnectionStartedCallback =
        LoggerMessage.Define<string>(LogLevel.Debug, new EventId(1, "ConnectionStarted"), "Connection {ConnectionId} started", true);

    private static partial void ConnectionStarted(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.String connectionId)
    {
        if (logger.IsEnabled(global::Microsoft.Extensions.Logging.LogLevel.Debug))
        {
            __ConnectionStartedCallback(logger, connectionId, null);
        }
    }
}

So in LoggerMessage.Define true is passed in to skip the IsEnabled-check, which is good.
But in the "logging method" IsEnabled is checked, regardless if our code already checked it.

Note: the IsEnabled check isn't free either, I'll defer to @davidfowl's comment: #50334 (comment)

Thus I propose to extend

[AttributeUsage(AttributeTargets.Method)]
public sealed class LoggerMessageAttribute : Attribute
{
    public LoggerMessageAttribute() { }
    public int EventId { get; set; } = -1;
    public string? EventName { get; set; }
    public LogLevel Level { get; set; } = LogLevel.None;
    public string Message { get; set; } = "";
+   public bool SkipEnabledCheck { get; set; } = false;
}

so the above example could be written as:

public static partial class Log
{
    // ...

    [LoggerMessage(EventId = 1, EventName = "ConnectionStarted", Level = LogLevel.Debug, Message = "Connection {ConnectionId} started", SkipEnabledCheck = true)]
    private static partial void ConnectionStarted(this ILogger logger, string connectionId);
}

and the generated code to be like:

partial class Log
{
    private static readonly Action<ILogger, string, Exception?> __ConnectionStartedCallback =
        LoggerMessage.Define<string>(LogLevel.Debug, new EventId(1, "ConnectionStarted"), "Connection {ConnectionId} started", true);

    private static partial void ConnectionStarted(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.String connectionId)
    {
        __ConnectionStartedCallback(logger, connectionId, null);
    }
}

That way IsEnabled is checked only once, if the user is aware of that pattern and opts-into this behaviour.

/cc: @maryamariyan

---

PS: should this be a formal api proposal? I didn't chose that template, as this api isn't shipped public

Author:	gfoidl
Assignees:	-
Labels:	area-Extensions-Logging, untriaged
Milestone:	-

[davidfowl]

It should be doing this by default AFAIK. The if check should always be in the generated code.

[gfoidl]

The if check should always be in the generated code.

Currently it is, but I'd like to get rid of it to avoid the double-check.

[davidfowl]

Oh I thought it was skipping already, I don't think it should be an option, just always skip the check.

[gfoidl]

just always skip the check.

Agree.
But it should be an option, so that it can be passed to LoggerMessage.Define.

From the proposal above we could get these cases:

SkipEnabledCheck = false

skipEnabledCheck: false passed to LoggerMessage.Define then there's the check for IsEnabled.

SkipEnabledCheck = true

skipEnabledCheck: true passed to LoggerMessage.Define so that there's no check for IsEnabled, and the user is responsible for checking that.

The Generated code will in all cases look like:

partial class Log
{
    private static readonly Action<ILogger, string, Exception?> __ConnectionStartedCallback =
        LoggerMessage.Define<string>(LogLevel.Debug, new EventId(1, "ConnectionStarted"), "Connection {ConnectionId} started", /* value from the SkipEnabledCheck property */);

    private static partial void ConnectionStarted(this global::Microsoft.Extensions.Logging.ILogger logger, global::System.String connectionId)
    {
        __ConnectionStartedCallback(logger, connectionId, null);
    }
}

[davidfowl]

I don't think so. It's always better to turn it off and generate the if directly so that that check can be inlined into the caller. The check inside of the delegate call can't be inlined into the caller (the JIT can't see though delegates yet).

[gfoidl]

Then we are back to the initial proposal (top comment).

If the user-code already has a logger.IsEnabled check, so the generated code shouldn't check it again.

[davidfowl]

Ah that makes sense now