Logging in EF Core Caching Provider

Note

This feature is only available in NCache Enterprise Edition.

The logging mechanism used inside NCache’s Entity Framework Core Caching provider has been adopted from Entity Framework Core. This logging mechanism works as follows:

Create a logger by providing appropriate implementations of ILoggerProvider and ILogger interfaces in 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 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 user provided path with 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 log level provided by user.
[null]	[value]	[value]	[value]	Default Logger (`NCacheLogger`) will log to user provided path with log level provided by user.
[value]	[null]	[null]	[value]	Loggers from user provided factory are used to log to wherever user has logged to in 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 category name. Value for path and log level is ignored.
[value]	[null]	[value]	[value]	Loggers from user provided factory are used to log to wherever user has logged to in 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 category name. Value for path and log level is ignored.
[value]	[value]	[null]	[value]	Loggers from user provided factory are used to log to wherever user has logged to in 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 category name. Value for path and log level is ignored.
[value]	[value]	[value]	[value]	Loggers from user provided factory are used to log to wherever user has logged to in 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 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

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 (current directory in case of no installation) in the same format as 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 default NCache Logger with log level Trace and logs 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 default values for logging at Debug level.

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