Logging in EF Core

In this article let us find out how Logging in EF Core works. We use logging to Log SQL queries. Find out more about errors. Improve Performance of the SQL Queries etc. In the article, we will create an example application and show you how to log queries to console and also to the windows event log. We also show you how to filter the logs using the log levels & DbLogger Category.

Why Logging

There are a lot of scenarios, where you would see the queries the EF Core generates. For Example, the Query may fail to bring the desired result or when the query itself is slow. Looking and analyzing the query that is sent to the back end server help us to write better queries and fine-tune performance bottlenecks.

EF Core has come with a lot of logging capabilities out of the box. All we need to capture it and direct it to a text file or console or another database.

Logging in .NET Core

.NET Core apps have built-in mechanisms for creating & managing various loggers. At the heart of the Logging API is three players LoggerProvider, Logger & LoggerFactory.

Logger is what writes the log entities to output. The output can be a console, database a text file etc. It must implement the interface ILogger

The LoggerProvider must implement the interface ILoggerProvider. The responsibility of the LoggerProvider to create the Logger. The re are many built-in LoggerProviders available for us to use. The following is the list of some of them.

The LoggerFactory contains the collection of LoggerProvider. We add the LoggerProvider to the LoggerFactory. Since it is a collection, it gives us the ability to log to multiple locations using different providers. It is the responsibility of the LoggerFactory to create the instance of the ILoggerProvider. The LoggerProvider then creates the instance of the Logger.

Logging To Console

The DBContext generates a lot of log information. All we need to do is tie up the LoggerProvider to it.

The way it is done in a console application is a little different from an ASP.NET Core application. In ASP.NET Core apps the LoggerFactory is already set up by the framework. It is also automatically tied up to the DBContext class.

EF Core Console App

First, create an EF Core Console Application as shown in the tutorial. The tutorial uses Visual Studio 2017. But you can also use the Visual Studio 2019 and Dot net core 3.x.

Console Logger Provider

The next step is to install the Logger Provider. The list above contains some of the built in loggers. Let us use the Console Logger Provider. Install it using the following command.

Install-Package Microsoft.Extensions.Logging.Console

Logger Factory & Logger Provider

First, we need to create the Logger Factory

Open the EFContext class and add the following at top

public static readonly ILoggerFactory MyLoggerFactory =
   LoggerFactory.Create(
        builder =>
          {
              builder.AddConsole();
           }
   );

We LoggerFactory.Create is a static method, which creates the LoggerFactory. It gets the builder as its argument. The purpose of it is to configure the LoggerProvider.

We declare the MyLoggerFactory as static. Because the Context must use the same instance of the LoggerFactory for the entire duration of the application lifetime. Otherwise, it will have performance side effects

The AddConsole is an extension method from the Microsoft.Extensions.Logging.Console package. It configures the LoggerProvider and adds it the LoggerFactory.

With this our LoggerFactory is ready. Now time to hook it up to the DBContext. We do it while Configuring the DBContext using the OnConfiguring Method. Pass our LoggerFactory using the UseLoggerFactory method.

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
   {
      optionsBuilder
         .UseLoggerFactory(MyLoggerFactory)
         .UseSqlServer(connectionString);
    }

Now, run the app and you will see the select query in your console screen.

Configure Logger

The above code logs everything, which is going to fill up the console. The logger provides a lot of filters to keep the log entries to minimum

EnableDetailedErrors

This EnableDetailedErrors option provides additional error details about the errors. Such errors most often about the misconfigured entity properties like int in place of string etc. This option is set to false by default. But when set to true it will include details of the specific entity property that generated the error. Enabling this option will incur a small performance hit.

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder
            .UseLoggerFactory(MyLoggerFactory)
            .EnableDetailedErrors(true)
            .UseSqlServer(connectionString);
     }

EnableSensitiveDataLogging

The EnableSensitiveDataLogging enables application data to include sensitive information in the logs. The sensitive information include the values assigned to properties of your entity instances, parameter values for commands being sent to the database, etc

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseLoggerFactory(MyLoggerFactory)
        .EnableSensitiveDataLogging(true)
        .UseSqlServer(connectionString);
}

Log Levels

The Logs are classified according to severity levels. The following table shows

LogLevel Enum

Use the AddFilter method to filter our the desired log level.

public static readonly ILoggerFactory MyLoggerFactory =
      LoggerFactory.Create(
          builder => {
             builder.AddConsole()
                    .AddFilter(level => level == LogLevel.Information);
          }
       );

DBLogger Category

Apart from the Log Levels, the logger API defines several DBLogger categories. We can use them to filter out the log.

public static readonly ILoggerFactory MyLoggerFactory2 =
  LoggerFactory.Create(
      builder => {
        builder.AddConsole()
               .AddFilter((category, level) 
                    => category == DbLoggerCategory.Database.Command.Name 
                    && level == LogLevel.Information);
      });

Logging To EventLog

Now, you have understood how to implement the logging in EF Core Console Application, we can easily use any other provider. For Example install the following package, which is a LoggerProvider to EventLog

install-package Microsoft.Extensions.Logging.EventLog

Now, use the AddEventLog extension method to send the logs to the windows event log along with the console. You can also use the addfilter method to filter out the logs.

 public static readonly ILoggerFactory MyLoggerFactory1 =
        LoggerFactory.Create(
           builder =>
                {
                   builder.AddConsole();
                   builder.AddEventLog();
                }
       );

Summary

Logging in EF core helps us find out more information about the errors. It helps to fine tune our queries, thus helping us in improving the performance.