Logging Configuration in ASP.NET Core Zero

In the previous article, we discussed the fundamental concepts of logging—including its purpose, categories of logs, and common log levels. In this part, we’ll delve into how to configure logging providers in ASP.NET Core to ensure your application can flexibly and effectively record the required log information.

What Is a Logging Provider?

A logging provider is a concrete implementation responsible for writing log entries to specific destinations—such as the console, files, databases, or external services. ASP.NET Core ships with several built-in logging providers and also supports custom logging providers developed by third parties or your own team.

Configuring Logging Providers

In ASP.NET Core, logging providers are typically configured in the Program.cs file. By default, newly created ASP.NET Core projects already include basic logging providers—namely, the Console and Debug providers. Below, we walk through how to configure and add additional logging providers.

1. Default Configuration

Here’s an example of a minimal Program.cs file for a new ASP.NET Core application, which already includes console and debug logging:

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

In this example, ASP.NET Core uses the CreateDefaultBuilder method to automatically register the Console and Debug logging providers.

2. Adding a File-Based Logging Provider

To persist log entries to disk, you can integrate libraries such as Serilog. The following steps demonstrate how to add file-based logging using Serilog.

2.1 Install Required NuGet Packages

Add the following NuGet packages to your project:

dotnet add package Serilog.AspNetCore
dotnet add package Serilog.Extensions.Logging
dotnet add package Serilog.Sinks.File

2.2 Configure Serilog

Next, configure Serilog in Program.cs:

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
using Serilog;

public class Program
{
    public static void Main(string[] args)
    {
        Log.Logger = new LoggerConfiguration()
            .MinimumLevel.Information()
            .WriteTo.Console()
            .WriteTo.File("logs/log-.txt", rollingInterval: RollingInterval.Day)
            .CreateLogger();

        try
        {
            Log.Information("Application Starting");
            CreateHostBuilder(args).Build().Run();
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, "Application Start-up Failed");
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .UseSerilog() // Enable Serilog
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

Here, Serilog is configured with a minimum log level of Information, and output is directed to both the console and a rotating file. A new log file is generated daily, named in the format log-YYYYMMDD.txt.

3. Configuring Log Levels

You can dynamically adjust verbosity across environments by configuring log levels in appsettings.json. For example:

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

In this configuration:

• The default log level is set to Information.
• All log entries under the Microsoft namespace (e.g., framework internals) are suppressed below Warning.
• Microsoft.Hosting.Lifetime messages remain at Information, ensuring startup/shutdown events are visible.

Summary

In this article, we explored how to configure logging providers in ASP.NET Core—including integrating Serilog for file-based logging. Thoughtful configuration of logging providers enables flexible, environment-aware log management—helping you diagnose issues quickly and monitor application health effectively.

In the next article, we’ll cover how to write log entries, and how to leverage different log levels to capture meaningful, actionable insights. Stay tuned!