20. Logging

Logging in ASP.NET Core

Logging is an indispensable tool for monitoring, troubleshooting, and gaining insights into your ASP.NET Core application’s behavior. It serves as a window into your application’s runtime events, allowing you to track everything from routine operations to critical errors.

---

ILogger

At the core of ASP.NET Core’s logging infrastructure is the ILogger<T> interface. It provides a standardized way to emit log messages, warnings, errors, and other diagnostic information from your application code.

1. Abstraction

• Flexibility: ILogger<T> is an interface, meaning you can plug in various logging providers (e.g., console, file, database, cloud-based services) without changing your application code.
• Adaptability: This abstraction layer allows you to switch logging providers or modify their configurations seamlessly.

2. Log Levels

• Severity Categories: ILogger<T> supports a hierarchy of log levels, representing the severity of log events:
  • Trace: Very fine-grained, detailed diagnostic events. Usually only enabled during development.
  • Debug: Debugging information that’s less verbose than trace-level logs.
  • Information: Informational messages about normal application behavior.
  • Warning: Events that might indicate potential issues but don’t necessarily disrupt the application.
  • Error: Errors or exceptions that have occurred and might impact the user experience.
  • Critical: Critical errors or failures that require immediate attention.
• Filtering: You can configure logging providers to filter out log messages based on their level.

3. Structured Logging

• Beyond Plain Text: Structured logging goes beyond simple text messages by incorporating key-value pairs (properties) into your log events.
• Enhanced Analysis: This structure makes it significantly easier to filter, search, and analyze log data using tools like Seq or Elasticsearch.
• Example: Instead of logging “User ‘JohnDoe’ logged in”, you can log an event with properties:
  • EventName: “UserLogin”
  • UserName: “JohnDoe”

4. Dependency Injection

• Seamless Access: You typically acquire an ILogger<T> instance using dependency injection.
• Controller Example:

public class PersonsController : Controller
{
    private readonly ILogger<PersonsController> _logger; // Injected logger
 
    public PersonsController(ILogger<PersonsController> logger)
    {
        _logger = logger;
    }
}

• Generic Type Argument: The generic type parameter (e.g., ILogger<PersonsController>) specifies the category name for the logger, which is often the class name where the logger is being used.

---

Logging Configuration

appsettings.json

The default configuration file where you specify your logging preferences.

LogLevel Section: Within the Logging section, you control the minimum log levels for different categories and providers.

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",      // Default log level for most categories
            "Microsoft.AspNetCore": "Warning" // More specific setting for ASP.NET Core logs
        }
    }
}

Filtering: Use the Filter section to define more granular rules for excluding or including specific categories or log levels.

---

Logging Providers

Built-in Providers

ASP.NET Core includes several logging providers out of the box:

• Console: Logs to the console.
• Debug: Logs to the Visual Studio debugger output window.
• EventSource: Logs structured events for consumption by Event Tracing for Windows (ETW).
• EventLog (Windows only): Logs to the Windows Event Log.

Third-Party Providers

• Serilog: A highly recommended option for its powerful structured logging capabilities and extensive collection of sinks (output targets).
• NLog, log4net: Other well-established logging frameworks.

---

HTTP Logging

ASP.NET Core provides built-in middleware for logging HTTP requests and responses. This is useful for:

• Troubleshooting: Tracking the flow of requests and responses.
• Performance Analysis: Identifying slow requests or bottlenecks.
• Security Audits: Logging request details for security analysis.

UseHttpLogging() Middleware

• Purpose: Adds middleware to the pipeline to log HTTP request and response information.
• Placement: Add this middleware early in your Program.cs to capture all subsequent requests.

HttpLoggingOptions

• Purpose: Allows you to customize what gets logged.
• Key Options:
  • LoggingFields: Control which fields are logged (e.g., request path, method, status code, headers).
  • RequestHeaders, ResponseHeaders: Specify which headers to include.

Code Example: Program.cs

if (builder.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}
 
app.UseHttpLogging(); // Enable HTTP logging
 
// ... other middleware and routing ...

Controller

In your PersonsController:

• ILogger<PersonsController> _logger: The controller receives an ILogger<T> instance through constructor injection. The generic type PersonsController sets the category name for the logger.

appsettings.json

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft.AspNetCore": "Warning"
        }
    }
}

• "Default": "Information": Sets the default log level to Information.
• "Microsoft.AspNetCore": "Warning": Sets the log level for ASP.NET Core-related logs to Warning.

Notes

• ILogger Interface: The core of logging in ASP.NET Core.
• Log Levels: Use appropriate levels to categorize the severity of events.
• Structured Logging: Include key-value pairs for better analysis.
• Configuration: Control log levels and filtering in appsettings.json.
• Providers: Choose the right provider for your needs (e.g., Serilog for structured logging).
• HTTP Logging: Use UseHttpLogging() to track requests and responses.
• Dependency Injection: Obtain ILogger<T> instances through DI.

---

Serilog: Structured Logging Powerhouse

Code Walkthrough: Program.cs

// Program.cs
 
builder.Host.UseSerilog((HostBuilderContext context, IServiceProvider services, LoggerConfiguration loggerConfiguration) => {
    loggerConfiguration
        .ReadFrom.Configuration(context.Configuration)   // Extracts logging configuration from appsettings.json
        .ReadFrom.Services(services);                    // Injects services (like IWebHostEnvironment) into Serilog's context
});
 
var app = builder.Build();
 
app.UseSerilogRequestLogging(); // Enable Serilog's request logging middleware
 
if (builder.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}
 
app.UseHttpLogging(); // Enable basic HTTP logging
 
// ...

• UseSerilog() (Host Level): Configures Serilog as the logging provider for the application.
• UseSerilogRequestLogging(): Enables Serilog’s request logging middleware.
• UseHttpLogging(): Activates basic HTTP logging functionality.

Controller: Leveraging the Injected Logger

In your PersonsController:

private readonly ILogger<PersonsController> _logger;

An instance of ILogger<T> is injected into the controller via its constructor. The type parameter PersonsController designates the category for log messages emitted from this controller.

appsettings.json

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft.AspNetCore": "Warning"
        }
    }
}

---

Key Points to Remember

Logging in ASP.NET Core

• ILogger Interface: The foundation for structured logging in ASP.NET Core. Provides methods for logging messages at different levels (Trace, Debug, Information, Warning, Error, Critical).
• Dependency Injection: Obtain ILogger<T> instances through constructor injection in your classes.
• Configuration: Control log levels and filtering rules in appsettings.json.
• Logging Providers:
  • Built-in: Console, Debug, EventSource, EventLog (Windows only).
  • Third-party: Serilog, NLog, log4net.

Serilog: Structured Logging Powerhouse

• Benefits:
  • Structured Logging: Log events as key-value pairs for easier searching and filtering.
  • Flexibility: Supports various sinks (output targets) and is highly extensible.
• Key Concepts:
  • Sinks: Destinations for your logs (console, file, database, Seq, etc.).
  • Enrichers: Add context to your log events (e.g., user ID, machine name).
  • IDiagnosticContext: Attach temporary properties to log events (e.g., transaction IDs).
  • Serilog Timings: Measure and log the duration of operations.

Important Serilog Components

• File Sink: Writes logs to text files, supports rolling files.
• Database Sink: Stores logs in a relational database.
• Seq Sink: Sends logs to Seq, a centralized log management platform.
• RequestId Enricher: Adds a unique request ID to each log event.

Code Snippets

Configuring Serilog in Program.cs:

builder.Host.UseSerilog((ctx, services, config) => config
    .ReadFrom.Configuration(ctx.Configuration)
    .ReadFrom.Services(services));

Logging in a Controller:

_logger.LogInformation("User {UserName} logged in", user.UserName);

Best Practices

• Choose Wisely: Select the right logging provider(s) for your needs.
• Configure Sensibly: Adjust log levels based on the environment.
• Structured Logging: Embrace structured logging for powerful analysis.
• Sensitive Data: Never log sensitive information directly.
• Centralized Logging: Use a centralized log management system like Seq for better insights.
• Performance: Be mindful of logging overhead, especially in production.

Interview Tips

• Explain the Why: Articulate the benefits of logging and the problems it solves.
• Structured Logging: Highlight the advantages of structured logging over plain text logging.
• Serilog: Showcase your knowledge of Serilog’s features and sinks.
• Best Practices: Discuss the importance of proper configuration, security considerations, and performance optimization in logging.