10 Serilog Best Practices

Serilog is a powerful logging library for .NET applications. It provides a simple API for logging structured data and can be used to log to a variety of destinations, including files, databases, and cloud services.

In this article, we’ll discuss 10 best practices for using Serilog in your .NET applications. We’ll cover topics such as logging levels, log formatting, and log rotation. By following these best practices, you can ensure that your application’s logs are organized, easy to read, and secure.

1. Use the right sink for your needs

Different sinks have different capabilities and features, so it’s important to choose the one that best fits your needs. For example, if you need to store log data in a database, then you should use a sink like Serilog.Sinks.MSSqlServer or Serilog.Sinks.MySQL.

On the other hand, if you want to send logs to an external service such as Slack or Loggly, then you should use a sink like Serilog.Sinks.Slack or Serilog.Sinks.Loggly. Each of these sinks has its own unique features and capabilities, so make sure to do your research before choosing the right one for your project.

2. Avoid using Serilog’s Console Sink in production

The Console Sink is designed for development and debugging purposes, not production. It’s meant to be used in a local environment where you can quickly view the output of your logs. In production, however, it’s best to use other sinks such as Seq or Splunk which are more suited for long-term storage and analysis.

Using the Console Sink in production can also lead to performance issues since it will write log messages directly to the console window. This can slow down your application and cause unnecessary strain on system resources.

3. Log to a file, not the console

Logging to the console is great for development, but it’s not ideal in production. Logs can quickly become overwhelming and difficult to read when they’re all dumped into the same place.

By logging to a file instead, you can easily separate out different types of logs (e.g., errors, warnings, etc.) and store them in their own files. This makes it much easier to search through your logs and find what you need. Additionally, you can configure Serilog to rotate log files so that old ones are archived and new ones created as needed.

4. Don’t use Serilog’s File Sink in production either

Serilog’s File Sink is designed to be used in development and testing environments, where the log files are only needed for a short period of time. In production, however, you need more robust logging solutions that can handle large amounts of data over long periods of time.

For example, if your application generates hundreds of megabytes of logs every day, Serilog’s File Sink will quickly become overwhelmed and unable to keep up with the demand. Additionally, it won’t provide any features such as alerting or analytics which are essential for monitoring and troubleshooting production applications.

Instead, use a dedicated logging solution such as Splunk, ELK Stack, or Loggly. These services offer powerful features such as real-time alerts, dashboards, and analytics that make it easier to monitor and debug your applications in production.

5. Use Seq or Elasticsearch instead of Serilog’s File and Console Sinks

Serilog’s File and Console Sinks are designed for development purposes, not production. They can quickly become overwhelmed with log data, leading to performance issues or even data loss. Seq and Elasticsearch provide more robust logging solutions that are better suited for production environments.

Seq is a centralized logging platform that allows you to store, search, and analyze your logs in real-time. It also provides powerful features such as alerting, filtering, and dashboards. Elasticsearch is an open source distributed search engine that enables you to store and query large amounts of structured and unstructured data. Both of these tools offer superior scalability and reliability compared to Serilog’s File and Console Sinks.

6. Use structured logging

Structured logging allows you to store your log data in a structured format, which makes it easier to query and analyze. This is especially useful when dealing with large amounts of log data, as it can be difficult to parse through unstructured logs.

Structured logging also helps ensure that all the necessary information is included in each log entry. By using Serilog’s built-in properties, such as timestamp, level, message, etc., you can make sure that all the relevant details are captured in each log entry. This makes it much easier to search for specific entries or troubleshoot issues.

7. Use meaningful context properties

Context properties are key-value pairs that you can add to your log messages. They provide additional information about the event being logged, such as the user ID or the request URL.

By adding meaningful context properties to your logs, you make it easier for yourself and other developers to quickly identify what’s happening in the application. For example, if you’re logging an error message, you could include a property with the name of the method where the error occurred. This makes it much easier to find the source of the problem.

Context properties also help when searching through logs. You can use them to filter out irrelevant events and focus on the ones that matter.

8. Use Enrichments

Enrichments allow you to add additional context to your log messages, which can be incredibly useful for debugging and troubleshooting.

For example, if you’re logging an error message, you might want to include the user’s IP address or browser type in the log message. This way, when you look at the log later on, you’ll have more information about what happened leading up to the error.

Enrichments are also great for adding contextual data that is not directly related to the log message itself. For instance, you could use enrichments to add tags to each log message so that you can easily filter them by category.

Overall, using enrichments is a great way to make sure that your logs contain all of the necessary information needed to debug and troubleshoot issues quickly and efficiently.

9. Use an ILoggerFactory extension method to configure Serilog

Using an ILoggerFactory extension method to configure Serilog allows you to keep your configuration code in one place, making it easier to maintain and debug. It also makes it easier to switch between different logging frameworks if needed. Additionally, using an ILoggerFactory extension method ensures that all of the loggers created by the factory are configured with the same settings. This helps ensure consistency across your application’s logs.

10. Use the static logger class (Log) only when you can’t inject it

When you use the static logger class, it’s difficult to test your code because you can’t easily mock or stub out the logging calls. This means that if you want to unit test your code, you have to write a lot of extra code to make sure that all of the logging calls are properly handled.

On the other hand, when you inject the logger into your classes, you can easily mock and stub out the logging calls in your tests. This makes testing much easier and more efficient.