Introduction to Logging in .NET Core

6 November 2017

Logging is an essential part of any software application, and in modern development, it plays a key role in monitoring, troubleshooting, and improving your application. In .NET Core, logging is built-in and highly configurable, making it easy to track events and errors within your application. In this post, we will explore how to set up logging in .NET Core applications and look at some best practices for logging and error tracking.

1. Why Is Logging Important?

Logging allows you to track what’s happening inside your application during runtime. It helps developers:

• Diagnose and debug issues in production.
• Monitor application performance and health.
• Gather insights into user behavior and application usage.

In .NET Core, logging is done through a built-in framework that offers flexibility and scalability. Logging enables you to track everything from simple events, like user interactions, to critical application failures.

2. Setting Up Logging in .NET Core

Setting up logging in .NET Core is simple, thanks to its integrated logging system. By default, .NET Core uses ILogger interface, which can log to various outputs (console, file, etc.) depending on how it’s configured.

a. Configure Logging in Startup.cs

To set up logging in a .NET Core application, you can configure it in the Startup.cs file in the ConfigureServices method.

Here’s a basic setup for logging:

public void ConfigureServices(IServiceCollection services)
{
    // Configure logging
    services.AddLogging(builder =>
    {
        builder.AddConsole();  // Log to the console
        builder.AddDebug();    // Log to the debug output
        builder.AddFile("Logs/myapp.txt");  // Log to a file (requires additional package)
    });

    services.AddControllers();
}

In this setup:

• AddConsole() will log messages to the console.
• AddDebug() logs to the debug output window.
• AddFile() is used to log messages to a file (this requires an additional package, e.g., Serilog).

b. Using the Logger in Your Application

Once logging is set up, you can inject ILogger<T> into any class (typically controllers or services) to start logging events.

Here’s an example of logging inside a controller:

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

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

    public IActionResult Get()
    {
        _logger.LogInformation("GET request received");

        try
        {
            // Your logic here
            return Ok();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred while processing the GET request");
            return StatusCode(500, "Internal server error");
        }
    }
}

In this example:

• LogInformation is used to log informational messages.
• LogError is used to log errors, along with the exception details, when something goes wrong.

3. Log Levels in .NET Core

.NET Core logging system provides several log levels, each corresponding to a severity level. You can filter and configure which levels of logs are captured based on your needs.

Here are the different log levels available in .NET Core:

• Trace: Logs the most detailed information, typically only used for debugging.
• Debug: Logs information useful for debugging but can be more general than trace logs.
• Information: General logs that track application events and workflow.
• Warning: Logs that indicate a potential problem, but the application is still functioning normally.
• Error: Logs that indicate an issue occurred, potentially causing the operation to fail.
• Critical: Logs indicating a severe problem, typically resulting in an application shutdown.

Example of using log levels:

_logger.LogTrace("This is a trace message.");
_logger.LogDebug("This is a debug message.");
_logger.LogInformation("This is an information message.");
_logger.LogWarning("This is a warning message.");
_logger.LogError("This is an error message.");
_logger.LogCritical("This is a critical error message.");

By setting the desired log level in the logging configuration, you can control what gets logged based on severity. For example, in production environments, you might only want to log Warning, Error, and Critical messages, while in development, you might log everything, including Trace and Debug.

4. Best Practices for Logging and Error Tracking

Logging is not just about setting up a logging framework but also about logging intelligently and following best practices to make your logs useful. Here are some tips to improve the quality of your logs:

a. Log Meaningful Information

Your logs should be detailed enough to help with debugging but not so verbose that they overwhelm you. Log critical information such as:

• Method entry/exit.
• Input parameters for actions.
• Errors, along with exception details (stack traces).
• Key actions that drive the business logic.

b. Use Structured Logging

Structured logging allows logs to be easily searched, filtered, and analyzed. In .NET Core, you can log in a structured way by using Serilog or other logging frameworks that support structured data.

For example, with Serilog, you can log data like this:

_logger.LogInformation("User {UserId} has logged in from IP address {IpAddress}", userId, ipAddress);

This makes it easier to filter and analyze logs in centralized logging systems.

c. Log Exceptions with Stack Traces

Whenever an exception occurs, make sure to log the full exception with its stack trace. This will provide more context and allow you to quickly identify where the error originated.

_logger.LogError(ex, "An error occurred while processing the request.");

d. Avoid Logging Sensitive Information

Be careful not to log sensitive data, such as passwords, credit card numbers, or other personally identifiable information (PII). Logging such data can result in security vulnerabilities.

e. Use External Tools for Centralized Logging

In large-scale applications, it’s important to use external tools to centralize and monitor logs. Some popular tools include:

• Elasticsearch, Logstash, Kibana (ELK Stack): For aggregating and visualizing logs.
• Serilog: A powerful logging library for structured logging.
• Seq: A log server that integrates with Serilog for real-time log analytics.
• Azure Application Insights: A service for monitoring applications in real-time with log analytics.

5. Conclusion

In this post, we’ve discussed how to set up logging in .NET Core applications, best practices for logging, and how to track errors. Logging is a fundamental part of any application, and by implementing good logging practices, you can ensure that your app is easier to maintain, debug, and monitor.

By centralizing your logging and using structured logs, you can gain valuable insights into the behavior and performance of your application, ultimately improving its reliability and user experience.

Happy coding!