Why is this an issue?

Logging arguments should not require evaluation in order to avoid unnecessary performance overhead. When passing concatenated strings or string interpolations directly into a logging method, the evaluation of these expressions occurs every time the logging method is called, regardless of the log level. This can lead to inefficient code execution and increased resource consumption.

Instead, it is recommended to use the overload of the logger that accepts a log format and its arguments as separate parameters. By separating the log format from the arguments, the evaluation of expressions can be deferred until it is necessary, based on the log level. This approach improves performance by reducing unnecessary evaluations and ensures that logging statements are only evaluated when needed.

Furthermore, using a constant log format enhances observability and facilitates searchability in log aggregation and monitoring software.

The rule covers the following logging frameworks:

• Microsoft.Extensions.Logging
• Castle.Core
• log4net
• Serilog
• Nlog

How to fix it

Use an overload that takes the log format and the parameters as separate arguments. The log format should be a constant string.

Code examples

Noncompliant code example

logger.DebugFormat($"The value of the parameter is: {parameter}.");

Compliant solution

logger.DebugFormat("The value of the parameter is: {Parameter}.", parameter);

Resources

Documentation

• Microsoft Learn - InterpolatedStringHandlerArgumentAttribute

Benchmarks

Glossary

• Mean
• Standard Deviation

The results were generated by running the following snippet with BenchmarkDotNet:

using Microsoft.Extensions.Logging;
using ILogger = Microsoft.Extensions.Logging.ILogger;

[Params(10_000)]
public int Iterations;

private ILogger ms_logger;
private Castle.Core.Logging.ILogger cc_logger;
private log4net.ILog l4n_logger;
private Serilog.ILogger se_logger;
private NLog.ILogger nl_logger;

[GlobalSetup]
public void GlobalSetup()
{
    ms_logger = new LoggerFactory().CreateLogger<LoggingTemplates>();
    cc_logger = new Castle.Core.Logging.NullLogFactory().Create("Castle.Core.Logging");
    l4n_logger = log4net.LogManager.GetLogger(typeof(LoggingTemplates));
    se_logger = Serilog.Log.Logger;
    nl_logger = NLog.LogManager.GetLogger("NLog");
}

[BenchmarkCategory("Microsoft.Extensions.Logging")]
[Benchmark]
public void MSLoggingTemplateNotConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        ms_logger.LogInformation($"Param: {i}");
    }
}

[BenchmarkCategory("Microsoft.Extensions.Logging")]
[Benchmark]
public void MSLoggingTemplateConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        ms_logger.LogInformation("Param: {Parameter}", i);
    }
}

[BenchmarkCategory("Castle.Core.Logging")]
[Benchmark]
public void CastleCoreLoggingTemplateNotConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        cc_logger.Info($"Param: {i}");
    }
}

[BenchmarkCategory("Castle.Core.Logging")]
[Benchmark]
public void CastleCoreLoggingTemplateConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        cc_logger.InfoFormat("Param: {Parameter}", i);
    }
}

[BenchmarkCategory("log4net")]
[Benchmark]
public void Log4NetLoggingTemplateNotConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        l4n_logger.Info($"Param: {i}");
    }
}

[BenchmarkCategory("log4net")]
[Benchmark]
public void Log4NetLoggingTemplateConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        l4n_logger.InfoFormat("Param: {Parameter}", i);
    }
}

[BenchmarkCategory("Serilog")]
[Benchmark]
public void SerilogLoggingTemplateNotConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        se_logger.Information($"Param: {i}");
    }
}

[BenchmarkCategory("Serilog")]
[Benchmark]
public void SerilogLoggingTemplateConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        se_logger.Information("Param: {Parameter}", i);
    }
}

[BenchmarkCategory("NLog")]
[Benchmark]
public void NLogLoggingTemplateNotConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        nl_logger.Info($"Param: {i}");
    }
}

[BenchmarkCategory("NLog")]
[Benchmark]
public void NLogLoggingTemplateConstant()
{
    for (int i = 0; i < Iterations; i++)
    {
        nl_logger.Info("Param: {Parameter}", i);
    }
}

Hardware Configuration:

BenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5247/22H2/2022Update)
12th Gen Intel Core i7-12800H, 1 CPU, 20 logical and 14 physical cores
  [Host]               : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256
  .NET 9.0             : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2
  .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256