Logging in EF Core Extension Methods

The logging mechanism used inside the NCache Entity Framework (EF) Core Extension Methods has been adopted from Entity Framework (EF) Core. This logging mechanism works as follows:

Note

This feature is also available in NCache Professional.

Create a logger by providing appropriate implementations of the ILoggerProvider and ILogger interfaces in the Microsoft.Extensions.Logging namespace.
Register logger in an instance of ILoggerFactory of Microsoft.Extensions.Logging.
Register this instance of ILoggerFactory in the OnConfiguring method of your database context.

For more details, please refer to Entity Framework (EF) Core logging documentation on Microsoft’s website.

NCache provides the ConfigureLogger method to configure the custom/default logger.

NCacheConfiguration.ConfigureLogger(
    ILoggerFactory factory = default(ILoggerFactory),
    string categoryName = default(string),
    string path = default(string),
    LogLevel logLevel = LogLevel.Debug
)

Parameter	Description	Default Value
`ILoggerFactory`	`LoggerFactory` instance registered to configure the logging mechanism.	`NCacheLogger`
`categoryName`	Category name for messages produced by the logger.	-
`path`	Path specifying where the logs will be created.	%NCHOME%\log-files (Windows) or /opt/ncache/log-files (Linux)
`logLevel`	Enum specifying the logging severity level. `Trace` = 0 `Debug` = 1 `Information` = 2 `Warning` = 3 `Error` = 4 `Critical` = 5 `None` = 6	`Debug`

This API can be called in the following ways:

Factory	Category Name	Path	Log Level	Behavior
[null]	[null]	[null]	[value]	Default Logger (`NCacheLogger`) will log to `%NCHOME%\log-files` (Windows) or `opt/ncache/log-files` (Linux) with log level provided by user.
[null]	[null]	[value]	[value]	Default Logger (`NCacheLogger`) will log to the user provided path with the log level provided by user.
[null]	[value]	[null]	[value]	Default Logger (`NCacheLogger`) will log to `%NCHOME%\log-files` (Windows) or `/opt/ncache/log-files` (Linux) with the log level provided by user.
[null]	[value]	[value]	[value]	Default Logger (`NCacheLogger`) will log to the user provided path with the log level provided by user.
[value]	[null]	[null]	[value]	Loggers from the user provided factory are used to log to wherever user has logged into his/her code. Category name is not ignored and provided to the factory when creating the logger. In case of null value, an empty string is passed as a category name. Value for path and log level is ignored.
[value]	[null]	[value]	[value]	Loggers from the user provided factory are used to log to wherever user has logged into the code. Category name is not ignored and provided to the factory when creating the logger. In case of null value, an empty string is passed as a category name. Value for path and log level is ignored.
[value]	[value]	[null]	[value]	Loggers from the user provided factory are used to log to wherever user has logged into his/her code. Category name is not ignored and provided to the factory when creating the logger. In case of null value, an empty string is passed as a category name. Value for path and log level is ignored.
[value]	[value]	[value]	[value]	Loggers from the user provided factory are used to log to wherever user has logged into his/her code. Category name is not ignored and provided to the factory when creating the logger. In case of null value, an empty string is passed as a category name. Value for path and log level is ignored.

For logs in NCache’s Entity Framework Core caching provider, there are two approaches:

Create custom implementation of the logging mechanism and provide instance of ILoggerFactory to the provider.
Use the provider’s default implementation of the logging mechanism.

Approach 1: Implement Custom Logging Mechanism for EFCore

Follow the steps mentioned below to implement custom logging with NCache.

Create Logger

public class Logger : ILogger
{
    public IDisposable BeginScope<TState>(TState state) => null;

     // Choose a logging level
    public bool IsEnabled(LogLevel logLevel) => logLevel == LogLevel.Debug;

    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
    {
        // log state and exception
    }
}

Create Logging Provider

Create a logging provider which extends the ILoggerProvider interface.

Warning

The logging provider has to return a valid logger, i.e., it cannot be null. Not doing so will throw an invocation exception due to the logger being used in Entity Framework without a check.

public class LoggerProvider : ILoggerProvider
{
    public ILogger CreateLogger(string categoryName)
    {
        return new Logger();
    }

    public void Dispose()
    {
        // dispose logger
    }
}

Configure Logging Provider

Configure the logging provider in the ConfigureLogger method within OnConfiguring method of the context:

public partial class NorthwindContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var factory = new LoggerFactory();
        factory.AddProvider(new LoggerProvider());
        NCacheConfiguration.ConfigureLogger(factory);
    }
}

Approach 2: Enable Default Logging

To enable default logging, you can specify the log level you wish to log in the OnConfiguring method of your database context. This will log all the log statements in NCache’s default log directory, i.e., the log-files folder in NCache’s install directory (the current directory in case of no installation) in the same format as the other log files of NCache. The default logging values for NCache's Logger are:

Parameter	Default Value
`ILoggerFactory`	`NCacheLogger`
`categoryName`	-
`path`	`%NCHOME%\log-files` (Windows) or `/opt/ncache/log-files` (Linux)
`logLevel`	`Debug`

The following command uses the default NCache Logger with the log level trace and logs them to the default path.

public partial class NorthwindContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        NCacheConfiguration.ConfigureLogger(logLevel:LogLevel.Trace);
    }
}

The following command uses all the default values for logging at the Debug level.

public partial class NorthwindContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        NCacheConfiguration.ConfigureLogger();
    }
}

Sample Code

NCache provides a sample application for EF Core on GitHub.