NLog

What is NLog?

NLog is a flexible and free logging platform for .NET applications. It helps developers capture and store information about what their application is doing, which is useful for debugging, monitoring, and troubleshooting. NLog has been around for a long time and is widely used in the .NET ecosystem.

---

Why Use NLog?

1. Flexibility: NLog supports a wide range of logging targets (called "targets" in NLog terminology), including the console, files, databases, email, and more.

2. Performance: NLog is designed to be fast and efficient, even in high-load scenarios.

3. Easy Configuration: NLog can be configured using XML files, code, or even appsettings.json in .NET Core applications.

4. Extensibility: You can create custom targets, layouts, and conditions to tailor NLog to your specific needs.

5. Rich Filtering: NLog provides powerful filtering options to control which log messages are written to which targets.

---

How Does NLog Work?

1. Setup: You configure NLog to specify where logs should go (e.g., console, file, database) and how they should be formatted.

2. Logging: In your code, you use NLog to write log messages (e.g., logger.Info("This is a log message")).

3. Output: NLog sends the logs to the destinations you configured.

---

Getting Started with NLog

To get started with NLog, you need to install the necessary NuGet packages:

dotnet add package NLog
dotnet add package NLog.Web.AspNetCore

---

Basic Configuration

NLog can be configured using an XML file (NLog.config) or directly in code. Here’s an example of configuring NLog using an XML file:

NLog.config

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      autoReload="true"
      throwConfigExceptions="true">
  <targets>
    <!-- Console Target -->
    <target name="console" xsi:type="Console" layout="${longdate}|${level:uppercase=true}|${logger}|${message}" />
    
    <!-- File Target -->
    <target name="file" xsi:type="File" fileName="logs/log.txt" layout="${longdate}|${level:uppercase=true}|${logger}|${message}" />
    
    <!-- Database Target -->
    <target name="database" xsi:type="Database">
      <connectionString>YourConnectionString</connectionString>
      <commandText>
        INSERT INTO Logs (Date, Level, Logger, Message) VALUES (@Date, @Level, @Logger, @Message);
      </commandText>
      <parameter name="@Date" layout="${date}" />
      <parameter name="@Level" layout="${level}" />
      <parameter name="@Logger" layout="${logger}" />
      <parameter name="@Message" layout="${message}" />
    </target>
  </targets>
  <rules>
    <logger name="*" minlevel="Debug" writeTo="console,file,database" />
  </rules>
</nlog>

---

Using NLog in Your Application

Here’s how you can use NLog in a .NET Core application:

using NLog;
using NLog.Web;

var logger = NLog.LogManager.Setup().LoadConfigurationFromAppSettings().GetCurrentClassLogger();

try
{
    var builder = WebApplication.CreateBuilder(args);

    // Add NLog to the DI container
    builder.Logging.ClearProviders();
    builder.Host.UseNLog();

    var app = builder.Build();

    app.MapGet("/", () => "Hello World!");

    app.Run();
}
catch (Exception ex)
{
    logger.Error(ex, "Application start-up failed");
    throw;
}
finally
{
    NLog.LogManager.Shutdown();
}

---

Using NLog in a Controller

In an ASP.NET Core application, you can inject the ILogger<T> interface into your controllers to log messages.

Example: Logging in a Controller

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

[ApiController]
[Route("api/[controller]")]
public class SampleController : ControllerBase
{
    private readonly ILogger<SampleController> _logger;

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

    [HttpGet]
    public IActionResult Get()
    {
        _logger.LogInformation("SampleController: Get method called.");

        try
        {
            // Simulate some work
            _logger.LogDebug("Simulating work...");
            return Ok("Hello from SampleController!");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred in the Get method.");
            return StatusCode(500, "Internal server error");
        }
    }
}

---

Using NLog in a Service

In a service class, you can inject the ILogger<T> interface to log messages.

Example: Logging in a Service

using Microsoft.Extensions.Logging;

public interface ISampleService
{
    void DoWork();
}

public class SampleService : ISampleService
{
    private readonly ILogger<SampleService> _logger;

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

    public void DoWork()
    {
        _logger.LogInformation("SampleService: DoWork method called.");

        try
        {
            // Simulate some work
            _logger.LogDebug("Doing some work...");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred in the DoWork method.");
            throw;
        }
    }
}

---

Using NLog in a Repository

In a repository class, you can inject the ILogger<T> interface to log messages.

Example: Logging in a Repository

using Microsoft.Extensions.Logging;

public interface ISampleRepository
{
    void SaveData();
}

public class SampleRepository : ISampleRepository
{
    private readonly ILogger<SampleRepository> _logger;

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

    public void SaveData()
    {
        _logger.LogInformation("SampleRepository: SaveData method called.");

        try
        {
            // Simulate saving data
            _logger.LogDebug("Saving data to the database...");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred in the SaveData method.");
            throw;
        }
    }
}

---

Registering Services and Repositories in Dependency Injection

To use the above services and repositories, you need to register them in the Program.cs or Startup.cs file.

Example: Registering Services and Repositories

var builder = WebApplication.CreateBuilder(args);

// Add NLog to the DI container
builder.Logging.ClearProviders();
builder.Host.UseNLog();

// Register services and repositories
builder.Services.AddScoped<ISampleService, SampleService>();
builder.Services.AddScoped<ISampleRepository, SampleRepository>();

var app = builder.Build();

app.MapControllers();

app.Run();

---

Logging Levels in NLog

NLog supports various logging levels, which you can use depending on the severity of the message:

• Trace: For very detailed logs, typically used for debugging.

• Debug: For debugging information.

• Info: For general informational messages.

• Warn: For warnings that might indicate a potential issue.

• Error: For errors that need attention.

• Fatal: For critical errors that cause the application to crash.

Example: Using Different Log Levels

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

---

Structured Logging with NLog

NLog supports structured logging, which allows you to log objects or key-value pairs for better analysis.

Example: Structured Logging

var user = new { Id = 1, Name = "John Doe" };
_logger.LogInformation("User logged in: {@User}", user);

This will log the user object in a structured format, making it easier to query and analyze logs.

---

Conclusion

NLog is a powerful and flexible logging library for .NET applications. It offers a wide range of features, including multiple logging targets, rich filtering options, and extensibility. Whether you need to log to the console, a file, a database, or even send logs via email, NLog has you covered. With its easy configuration and high performance, NLog is an excellent choice for .NET developers looking to implement robust logging in their applications.

By integrating NLog into your controllers, services, and repositories, you can effectively capture and analyze your application's behavior, making debugging and monitoring much easier.