Asp.Net Web Api Using Ilogger Interface Complete Guide

ASP.NET Web API Using the ILogger Interface

1. Overview of ILogger Interface

The ILogger interface serves as the primary point through which you log information within an ASP.NET Core application. It supports logging at different severity levels (e.g., Debug, Information, Warning, Error, Critical) and provides additional functionality, such as structured logging with named properties and scopes.

• Severity Levels: These categorize the nature of the message being logged.

  • Debug: Detailed diagnostic information typically of interest only when debugging an application.
  • Information: Information that can be useful for tracking the general flow of an application.
  • Warning: An indication that something unexpected happened, or indicative of some problem in the near future (e.g., ‘disk space low’). Generally, there is no immediate action required other than monitoring that the event occurred.
  • Error: An error occurred that should be investigated. This might not necessarily lead to a failure in the application but indicates that something went wrong.
  • Critical: A very severe failure in the application that needs immediate attention. Examples include loss of data connectivity, out-of-memory exceptions, disk failures, etc.

• Structured Logging: Logs messages are often written as structured data (e.g., JSON) rather than plain text, allowing for more powerful querying and analysis.

• Scopes: Define a logical operation scope, capturing correlation data for all logs created within its execution.

Example: Basic ILogger Usage

public class ValuesController : ControllerBase
{
    private readonly ILogger<ValuesController> _logger;

    public ValuesController(ILogger<ValuesController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IEnumerable<string> Get()
    {
        _logger.LogInformation("GET request received.");
        return new string[] { "value1", "value2" };
    }
}

Here, ILogger<ValuesController> is injected into the ValuesController, enabling structured logging with the correct category.

2. Configuring Logging Providers

ASP.NET Core supports multiple logging providers, such as console, file, event source, and third-party providers like Serilog, NLog, etc. Each provider outputs logs to a target sink.

• Built-in Providers:

  • Console Provider: Logs to the console.
  • Debug Provider: Logs to the debug output window in Visual Studio.
  • Event Viewer Provider: Logs to the Windows Event Log.
  • Event Source Provider: Writes logs that can be collected using various tools for troubleshooting and performance analysis.

• Third-party Providers:

• Serilog: Offers versatile logging to different sinks, rich formatting options, and support for advanced filtering.

• NLog: A flexible, high-performance logging solution with extensive extensibility capabilities.

Example: Configuring Console Logging Provider In the Program.cs file, configure the logging services to use the console provider.

var builder = WebApplication.CreateBuilder(args);

// Configure logging
builder.Logging.AddConsole();

var app = builder.Build();

3. Implementing Custom Logging

You can implement custom logging by creating your own logging provider and message formatter. This flexibility allows you to log data in a unique format or write logs to a unique destination.

Example: Creating a Simple Custom Logger Create a custom logger that writes log messages to a file.

public class FileLoggerProvider : ILoggerProvider
{
    private readonly string _filePath;
    
    public FileLoggerProvider(string filePath)
    {
        _filePath = filePath;
    }
    
    public ILogger CreateLogger(string categoryName)
    {
        return new FileLogger(_filePath);
    }
    
    public void Dispose() {}
}

public class FileLogger : ILogger
{
    private readonly string _filePath;

    public FileLogger(string filePath)
    {
        _filePath = filePath;
    }
    
    public IDisposable BeginScope<TState>(TState state) => null;

    public bool IsEnabled(LogLevel logLevel) => logLevel != LogLevel.None;

    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
    {
        if (!IsEnabled(logLevel))
            return;

        var message = formatter(state, exception);

        if (string.IsNullOrEmpty(message))
            return;

        // Write message to file
        File.AppendAllText(_filePath, $"{DateTime.UtcNow} [{logLevel}] {eventId.Id}: {message}{Environment.NewLine}");
    }
}

Use the custom logger in Program.cs.

builder.Services.AddSingleton<ILoggerProvider>(sp => new FileLoggerProvider("logs/myapp.log"));

4. Writing Scoped Logs

Using scoped logs can help in grouping related log messages and adding contextual information, making it easier to trace the execution path and identify where issues occur.

Example: Adding a Scope to Log Messages

[HttpPost]
public IActionResult Post([FromBody] MyModel model)
{
    using (_logger.BeginScope($"Processing POST request for Model ID={model.Id}"))
    {
        try
        {
            _logger.LogInformation("Model processing started.");
            
            // Process the model
            
            _logger.LogInformation("Model processed successfully.");
            
            return Ok();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing the model.");
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }
}

The scope is automatically disposed after the request processing ends.

5. Enriching Log Messages with Property Data

Enhance log messages with property data to increase their value for analysis. You can pass additional data to the log methods, which will appear in the structured log output.

Example: Including Properties in Log Messages

private readonly ILogger<WeatherForecastController> _logger;

public WeatherForecastController(ILogger<WeatherForecastController> logger)
{
    _logger = logger;
}

[HttpGet(Name = "GetWeatherForecast")]
public IEnumerable<WeatherForecast> Get()
{
    var rng = new Random();
    var forecasts = Enumerable.Range(1, 5).Select(index => new WeatherForecast
    {
        Date = DateTime.Now.AddDays(index),
        TemperatureC = rng.Next(-20, 55),
        Summary = Summaries[rng.Next(Summaries.Length)]
    })
    .ToArray();

    // Include properties in the log message
    _logger.LogInformation("Generated weather forecast", forecasts);

    return forecasts;
}

When viewed in a structured log viewer, the forecasts array will be included as part of the log message.

6. Filtering Log Messages

Configure log filters to control which log messages are generated and passed to each provider. This feature can significantly improve performance by reducing the amount of data processed and stored.

Example: Setting Filtering Rules

builder.Logging.AddFilter<ConsoleLoggerProvider>("Microsoft.AspNetCore.Authentication", LogLevel.Error);

This rule filters out all messages from the Microsoft.AspNetCore.Authentication category unless they are of level Error or higher.

7. Formatting Log Output

Define how log messages are formatted before being processed by each provider. Different providers may have different formatting requirements, and you can customize them per provider.

Example: Using Serilog for Advanced Formatting Install Serilog and its extensions via NuGet.

dotnet add package Serilog
dotnet add package Serilog.AspNetCore
dotnet add package Serilog.Sinks.File
dotnet add package Serilog.Settings.Configuration

Configure Serilog in Program.cs.

using Serilog;

var builder = WebApplication.CreateBuilder(args);

builder.Host.UseSerilog((ctx, lc) => lc.WriteTo.File("logs/serilog.txt"));
builder.Logging.AddConsole();

var app = builder.Build();

With Serilog, you can easily format logs in JSON or other formats suitable for modern logging infrastructure.

8. Integrating with Dependency Injection

Leverage the dependency injection (DI) system in ASP.NET Core to integrate logging seamlessly. DI helps manage the lifecycle of logger instances and simplifies testability and maintainability.

Example: Automatically Injecting ILogger As shown earlier, ILogger<ValuesController> is automatically injected by DI, ensuring that each controller has its appropriately named logger instance.

9. Logging in Middleware

Middleware components can utilize the ILogger interface to record important information about requests and responses. This is particularly useful for monitoring access patterns and diagnosing server-side issues.

Example: Logging HTTP Requests in Middleware

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestLoggingMiddleware> _logger;

    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("Request received {Scheme} {Host} {Path}", context.Request.Scheme, context.Request.Host, context.Request.Path);

        await _next(context);

        _logger.LogInformation(
            "Response sent {StatusCode}",
            context.Response.StatusCode);
    }
}

Register the middleware in Program.cs.