ASP.NET Core Logging Tutorial: What to Log and Best Practices

In the previous article, we thoroughly discussed configuring logging providers—covering how to select and configure different logging providers in ASP.NET Core applications. Logging is a critical component of any application: it helps monitor system health, troubleshoot issues, and gather runtime insights. In this article, we’ll delve deeper into how to log meaningful, well-structured content in ASP.NET Core applications.

Core Concepts of Logging

In ASP.NET Core, logging typically uses the ILogger<T> interface. Through dependency injection (DI), you can inject an ILogger instance into your classes and use it to write logs at various severity levels.

Here are the standard log levels:

• Trace: Highly detailed information—typically used only during development.
• Debug: Debugging information to help developers understand application behavior during development.
• Information: Routine operational messages indicating normal application flow.
• Warning: Indicates potential issues that aren’t yet errors but may require attention.
• Error: Records failures or exceptions that need follow-up investigation or remediation.
• Critical: Represents severe failures where the application may be unable to continue functioning.

Setting Up Logging

In practice, you’ll use ILogger in appropriate places—such as controllers, services, or middleware—to emit logs. By default, logging services are already registered in Startup.cs (or Program.cs in .NET 6+), so no additional setup is usually required for basic usage.

Example: Logging in a Controller

Below is a simple example demonstrating how to use ILogger inside a controller:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

namespace MyAspNetCoreApp.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class SampleController : ControllerBase
    {
        private readonly ILogger<SampleController> _logger;

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

        [HttpGet]
        public IActionResult Get()
        {
            _logger.LogInformation("Data retrieval request started");

            try
            {
                // Simulate data retrieval
                var data = GetData();
                _logger.LogInformation("Data retrieved successfully: {Data}", data);

                return Ok(data);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An error occurred while retrieving data");
                return StatusCode(500, "Internal Server Error");
            }
            finally
            {
                _logger.LogInformation("Data retrieval request completed");
            }
        }

        private string GetData()
        {
            // Simulate returning data
            return "Hello, World!";
        }
    }
}

In this example:

1. An ILogger<SampleController> instance is injected via the constructor using DI.
2. The Get() method emits logs at multiple levels—LogInformation() for routine events and LogError() for exceptions.
3. Placeholder syntax (e.g., {Data}) is used to safely interpolate dynamic values into log messages.

Formatting Log Content

Log messages support structured formatting via placeholders—enhancing readability and traceability. In the example above, {Data} serves as a named placeholder; ASP.NET Core automatically serializes and inserts the corresponding value.

Logging Complex Objects

Beyond simple strings, you can log rich objects with full structural fidelity:

var user = new { Name = "Alice", Age = 30 };
_logger.LogInformation("User details: {@User}", user);

Using the @ symbol before the placeholder ({@User}) tells the logger to serialize the object as structured data, preserving its properties and types—making logs far more valuable for analysis and diagnostics.

Why Thoughtful Logging Matters

Effective logging practices not only accelerate issue detection and resolution but also provide deep visibility into application behavior at runtime. Here are key recommendations to maximize logging effectiveness:

• Choose Appropriate Log Levels: Match severity to impact—don’t log critical business events as Trace, nor flood production with verbose Debug logs.
• Include Contextual Information: Add identifiers like UserId, RequestId, or correlation IDs to enable cross-log tracing and root-cause analysis.
• Avoid Excessive Logging: Over-logging harms performance and obscures signal with noise—log intentionally, not exhaustively.
• Support Auditing & Compliance: For regulated domains, explicitly log sensitive operations (e.g., financial transactions, permission changes) to satisfy audit requirements.

Closing Thoughts

This article explored how to record meaningful, structured log content in ASP.NET Core—and illustrated practical implementation through real-world code examples. Well-designed logging is foundational to building robust, maintainable, and observable applications.

In the next article, we’ll cover deploying ASP.NET Core applications to IIS—a crucial step toward moving from development to production environments. Be sure to read the upcoming installment to gain comprehensive knowledge on publishing and deployment workflows.