Logging serves as a crucial component of application development, functioning as a black box that records events, providing insight into what occurred when it took place and the reasons behind various actions. In this blog, I will guide you through the process of integrating Serilog, a robust structured logging library, into an ASP.NET Core MVC application. We will explore the necessary steps, starting from the installation of Serilog to its configuration for logging into both files and the console. Additionally, practical examples from a real-world project will be included to illustrate these concepts. Whether you are new to logging or seeking to enhance your diagnostic capabilities, this guide offers a comprehensive approach to achieving professional-grade logging.

What is Serilog?
Serilog is a clean, easy-to-setup logging library for .NET. It supports:

• Structured logging
• Multiple sinks (e.g., Console, File, Seq, etc.)
• Enrichment for contextual logs
• Rolling log files
• Helpful for Debugging

Step 1. Install Serilog Packages
Open the Package Manager Console in Visual Studio and run:
Install-Package Serilog.AspNetCore
Install-Package Serilog.Sinks.File
Install-Package Serilog.Sinks.Console

Step 2. Configure Serilog in Program.cs
Open your Program.cs file and configure Serilog like this:
using Serilog;

var builder = WebApplication.CreateBuilder(args);

// Configure Serilog
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Information()
    .WriteTo.Console()
    .WriteTo.File("Logs/log.txt", rollingInterval: RollingInterval.Day)
    .Enrich.FromLogContext()
    .CreateLogger();

builder.Host.UseSerilog();

builder.Services.AddControllersWithViews();

var app = builder.Build();

// Log application startup
Log.Information("Application is starting...");

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();
app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

try
{
    app.Run();
}
catch (Exception ex)
{
    Log.Fatal(ex, "Application terminated unexpectedly.");
}
finally
{
    Log.CloseAndFlush();
}

Step 3. Use Serilog in Your Controllers
You can inject ILogger<T> into your controllers like this:
public class TaskController : Controller
{
    private readonly ILogger<TaskController> _logger;

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

    public IActionResult Index()
    {
        _logger.LogInformation("Fetching all tasks...");
        return View();
    }

    public IActionResult Create()
    {
        _logger.LogInformation("Rendering Create Task view.");
        return View();
    }

    [HttpPost]
    public IActionResult Create(TaskModel model)
    {
        if (ModelState.IsValid)
        {
            _logger.LogInformation("Task created: {@Task}", model);
            // Save to DB (not shown)
            return RedirectToAction("Index");
        }

        _logger.LogWarning("Invalid task model submitted.");
        return View(model);
    }
}

// Use structured logging with {@Object} to log the full object for better diagnostics.

Clean Up
Always remember to flush logs using:
Log.CloseAndFlush();

This ensures all logs are written before your app shuts down.

Sample Log Output
Here's what your log.txt might look like:
[Information] Fetching all tasks...

[Information] Task created: { Title: "Write Blog", DueDate: "2025-04-15", IsCompleted: false }

[Warning] Invalid task model submitted.

Conclusion
The method of integrating Serilog into an ASP.NET Core MVC application is simple and efficient. Developers can have complete control over the logging process and specify exactly how and where logs are recorded by putting a few lines of configuration into place. This approach is useful not just during the development stage but also in production settings, where it is essential for efficient application monitoring and troubleshooting. This method works well for monitoring and debugging in production as well as during development.