Logging

Logging in C# - .NET

Learn about app logging provided by the Microsoft.Extensions.Logging NuGet package in C#.

https://learn.microsoft.com/en-us/dotnet/core/extensions/logging?tabs=command-line

Minimal template

This example is weak since it is not scaleable, performant, or configurable.

This sample console app relies on the following NuGet packages:

• Microsoft.Extensions.Logging

• Microsoft.Extensions.Logging.Console

using Microsoft.Extensions.Logging;

using ILoggerFactory factory = LoggerFactory.Create(builder => builder.AddConsole());
ILogger logger = factory.CreateLogger("Program");
logger.LogInformation("Hello World! Logging is {Description}.", "fun");

1. Create an ILoggerFactory here we set it so logs are written to the console - we call the place we write to a sink

2. Create the logger, and set the category to program ; a category is just a grouping

3. Log at information level, with a template where Description is set to fun

Logging a method call example

[LoggerMessage(LogLevel.Information, "MethodName was called")]
public static partial void MethodName(ILogger logger);

Advanced Logging

Typically most serious applications don’t use the Microsoft logging, and instead continue to use the ILogger API and use a third-party implementation like OTel for sending metrics off to Grafana and Serilog for structured logging.

The Generic and WebApp host both supply a DI ILogger , so no need to register just grab it like so.

partial class ExampleHandler(ILogger<ExampleHandler> logger)
{
    public void HandleRequest()
    {
        LogHandleRequest(logger);
    }

    [LoggerMessage(LogLevel.Information, "ExampleHandler.HandleRequest was called")]
    public static partial void LogHandleRequest(ILogger logger) 
    {
	    logger.LogInformation("Hello World! Logging is {Description}.", "fun");
    }
}

1. The primary constructor takes ILogger<TCategoryName>, if no logger exists with that category yet, a new one is created

Configuration

For hosted applications, configs are normally set in appsettings.env.json , within “Logging”

So to be clear, you are setting the minimum logging level based on the category

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
      "MyCategoryName": "Trace"
    }
  }
}

• Default is minimum logging level that is used, when not specified

• Microsoft is the specifies the minimum logging level that Microsoft can produce

• Microsoft.Hosting.Lifetime is the exception where the minimum is Information

You can set logging levels based on provider.

Note a provider is where you output your logs to, so debug is your debug window.

{
    "Logging": {
        "LogLevel": {
            "Default": "Error",
            "Microsoft": "Warning"
        },
        "Debug": {
            "LogLevel": {
                "Default": "Information",
                "Microsoft.Hosting": "Trace"
            }
        },
        "Console": {
            "LogLevel": {
                "Default": "Warning"
            }
        }
    }
}

Log Levels

0 is the lowest, 6 is the highest priority

Trace = 0, Debug = 1, Information = 2, Warning = 3, Error = 4, Critical = 5, and None = 6.

Event Ids

You can use event Ids to signal certain events, such as a read, or a certain failure.

using Microsoft.Extensions.Logging;

internal static class AppLogEvents
{
    internal static readonly EventId Read = new(1001, "Read");
    internal static readonly EventId ReadNotFound = new(4000, "ReadNotFound");
}

public sealed class AccountRepository(ILogger<AccountRepository> logger)
{
    public string? GetById(string accountId)
    {
        logger.LogInformation(AppLogEvents.Read, "Reading account {AccountId}", accountId);
	      logger.LogWarning(AppLogEvents.ReadNotFound, "Account {AccountId} was not found", accountId);
    }
}

using Microsoft.Extensions.Logging;

internal static partial class RepoLog
{
    [LoggerMessage(
        EventId = 1001,
        Level = LogLevel.Information,
        Message = "Reading account {AccountId}")]
    internal static partial void ReadingAccount(ILogger logger, string accountId);

    [LoggerMessage(
        EventId = 4000,
        Level = LogLevel.Warning,
        Message = "Account {AccountId} was not found")]
    internal static partial void AccountNotFound(ILogger logger, string accountId);
}

public sealed class AccountRepository(ILogger<AccountRepository> logger)
{
    public string? GetById(string accountId)
    {
        RepoLog.ReadingAccount(logger, accountId);
            RepoLog.AccountNotFound(logger, accountId);
    }
}