.NET Logging Guide:
Custom Logging Providers

In the previous articles in this series, we covered core concepts for logging in .NET, including frameworks, exception logging, common mistakes, security considerations and best practices. In part four, we discuss custom loggers and how to use

The Importance of Custom Loggers

Custom loggers are unique classes or functions for handling message logging from a single module or section of an application. They enable programmers to define custom behaviors such as message formatting and log filtering. By using custom loggers to help control the flow of log messages in distributed applications, software developers can more easily spot and fix problems when they occur.

.NET applications that need to log to particular destinations, such as cloud-based services or private databases, can leverage custom log providers to achieve this. Engineers can take advantage of the built-in logging capabilities of the .NET framework while creating custom log providers to easily integrate with their preferred logging destination.

Incorporating organization-specific tools into logging providers is also possible with custom loggers. These tools can be additional services that the organization uses for managing and analyzing log data in addition to the built-in features of a logging provider. For example, an organization might have a custom tool for searching and filtering log messages or creating alerts when specific types of log messages occur. This integration can enhance the overall effectiveness and efficiency of an organization's logging and monitoring procedures.

How to Create a Custom Logger

Before creating the custom logger, you must configure logging in your project. The Logging section of the app settings typically offers logging configuration. The code snippet below shows a sample configuration in JSON:

{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Error"
}
}
}

The above configuration sets the default logging of all categories at log level

Creating a custom logger class requires implementing the

The following code snippet shows the structure for creating a logger called

using Microsoft.Extensions.Logging;
// Implement the ILogger interface
public class CustomLogger : ILogger
{
public IDisposable BeginScope<TState>(TState state)
{
// Your code here
}
public bool IsEnabled(LogLevel logLevel)
{
// Your code here
}
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
{
// Your code here
}
}

The three functions to implement are

To implement your custom logger, you would override the three methods above.

The code snippet below shows the implementation of a custom logger that emits logs to a custom destination:

using Microsoft.Extensions.Logging;
public class CustomDestinationLogger : ILogger
{
// This is a client for an external log destination
private CustomLogDestinationClient logClient;
public CustomDestinationLogger()
{
// initialization code
}
public IDisposable? BeginScope<TState>(TState state) where TState : notnull => default!;
public bool IsEnabled(LogLevel logLevel) => true;
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
{
if(!IsEnabled(logLevel))
{
return;
}
// This line emits logs to a custom destination
logClient.Emit(eventId, state, exception, formatter);
}
}

In the preceding code, the