Fundamentals of Logging in .NET Core

Introduction

Logging is an essential aspect of application development, as it helps in tracking and troubleshooting issues, monitoring application behavior, and gathering valuable insights. In .NET Core, the built-in logging framework provides a flexible and customizable way to implement logging in your applications. This documentation will cover the fundamentals of logging in .NET Core, including key concepts and code examples.

Logging Providers

In .NET Core, logging providers are responsible for capturing and processing log messages. The framework offers various built-in logging providers, such as Console, Debug, EventSource, and File. Additionally, third-party logging providers can be integrated into your application.

Example: Configuring Console Logging Provider

csharp
using Microsoft.Extensions.Logging;

public class Program
{
    private static readonly ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
    {
        builder.AddConsole();
    });

    private static readonly ILogger logger = loggerFactory.CreateLogger<Program>();

    public static void Main(string[] args)
    {
        logger.LogInformation("Application started.");

        // Your application code here

        logger.LogInformation("Application stopped.");
    }
}

Explanation:

The ILoggerFactory is used to create an instance of the logger.
The AddConsole method is called to configure the console logging provider.
The CreateLogger method creates a logger instance associated with the Program class.
Log messages can be written using the LogInformation method, specifying the log level and the message.

Logging Levels

In logging, different levels are used to categorize log messages based on their severity and importance. The .NET Core logging framework supports several levels, including:

Trace
Debug
Information
Warning
Error
Critical

By setting the minimum logging level, you can control which log messages are recorded based on their level.

Logging Categories

Logging categories are used to organize and filter log messages based on different components or areas of your application. Categories help in identifying the source of log messages and provide a structured way to organize logs.

Example: Logging with Categories

csharp
using Microsoft.Extensions.Logging;

public class OrderService
{
    private readonly ILogger<OrderService> logger;

    public OrderService(ILogger<OrderService> logger)
    {
        this.logger = logger;
    }

    public void ProcessOrder(int orderId)
    {
        logger.LogInformation("Processing order {OrderId}", orderId);

        // Order processing logic

        logger.LogInformation("Order {OrderId} processed successfully.", orderId);
    }
}

Explanation:

The ILogger<T> interface is used to inject a logger instance into the OrderService class.
Log messages are written using the LogInformation method, providing a message template with placeholders for variables.
The orderId value is automatically substituted in the log message using the structured logging feature.

Configuration

Logging behavior can be customized and configured in the appsettings.json or through code.

Example: Configuring Logging via appsettings.json

json
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "MyApp.Namespace": "Debug"
    }
  }
}

Explanation:

The Logging section in the appsettings.json file defines the logging configuration.
The Default level is set to Information, meaning log messages with the Information level or higher will be recorded.
Log levels can be set globally or specific to a namespace (e.g., "MyApp.Namespace") or a provider (e.g., "Microsoft").

Conclusion

Logging is an integral part of any .NET Core application. This documentation provided an overview of the fundamentals of logging, including logging providers, levels, categories, and configuration. Understanding these concepts will enable you to implement effective logging strategies in your .NET Core projects.

Ticker

Fundamentals of Logging in .NET Core