• Webinars
  • Docs
  • Download
  • Blogs
  • Contact Us
Show / Hide Table of Contents
  • Programmer's Guide
  • Client Side API Programming
    • Setting Up Development Environment
    • Basic Cache Operations
      • Initialize Cache
      • Add Data to Cache
      • Update Data in Cache
      • Fetch Data From Cache
      • Remove Data From Cache
      • Dispose Cache
    • Bulk Operations
      • Adding Collection to Cache
      • Updating Collection in Cache
      • Retrieving Collection from Cache
      • Removing Collection from Cache
      • Deleting Collection from Cache
    • Asynchronous Operations
      • Using Asynchronous Operations
      • Using Asynchronous Operations with Callback Methods
    • Groups and Subgroups
      • Adding/Updating Data Group in Cache
      • Retrieving Data Group from Cache
      • Removing Data Group from Cache
    • Tagging Data in NCache
      • Creating Tags
      • Adding Items with Tags
      • Retrieving Previously Tagged Data
      • Removing Tagged Items from Cache
    • Named Tags
    • Data Expiration Strategies
      • Using Absolute Expiration
      • Using Sliding Expiration
    • Cache Dependencies
      • Key Dependency
      • File Dependency
      • Notification based Dependencies
        • Database Dependency using SQL Server
        • Database Dependency using Oracle
      • Polling Based Dependency
      • Custom Data Source Dependency
      • Multiple Cache Sync Dependency
      • Aggregate Dependency
      • Add Dependency to Existing Item
      • Using CLR Procedures to Call NCache
    • Locking Data in NCache
      • Locking Items in Cache (Pessimistic Locking)
      • Locking Items with Cache Item Versioning (Optimistic Locking)
    • SQL Reference for NCache
      • SQL Syntax
      • Querying Samples for Operators
      • Querying Data in NCache
      • NCache Language Integrated Query (LINQ)
        • Using LINQ in NCache
        • Configuring LINQPad for NCache
        • Querying NCache Data in LINQPad
    • Event Notifications
      • Cache Level Event Notifications
      • Item Level Event Notifications
      • Custom Event Notifications
    • Publish/Subscribe (Pub/Sub) in NCache
      • Pub/Sub Topics
      • Managing Topics
      • Pub/Sub Messages
        • Message Behavior and Properties
        • Creating a Message
      • Publish Messages to Topic
      • Subscribe for Topic Messages
      • Monitoring Pub/Sub Topics
    • Continuous Query
    • Using Streams in NCache
      • Opening with Stream Modes
      • Adding and Updating Data with Streams
      • Retrieving Data from Streams
      • Closing a Stream
    • Security and Encryption
      • NCache Security
      • NCache Data Encryption
    • Data Compression
    • NCache Management API
  • Server Side API Programming
    • Cache Startup Loader
      • Components of Cache Startup Loader
      • Sample Implementation of ICacheLoader on Single Node
      • Sample Implementation of ICacheLoader with Distribution Hints
    • Data Source Providers (Backing Source)
      • Read-Through Caching
        • Configure Read-Through Provider
        • Using Read-Through with Cache Operations
      • Write-Through Caching
        • Configuring Write-Through Provider
        • Using Write-Through with Basic Operations
        • Using Write-Behind with Basic Operations
        • Using Write-Behind with Bulk Operations
        • Using Write-Behind with Async Operations
        • Monitor Write-Through Counters
    • Custom Dependency
      • Sample Implementation of Custom Dependency
      • Sample Usage of Custom Dependency
    • WAN Replication through Bridge
      • Bridge Configurations
      • Implementing Bridge Conflict Resolver
    • Entry Processor
      • Sample Implementation of IEntryProcessor Interface
      • Sample Usage of EntryProcessor
    • MapReduce
      • Sample Implementation of MapReduce Interfaces
      • Sample Usage of MapReduce
    • Aggregator
      • Sample Implementation of IValueExtractor Interface
      • Sample Implementation of IAggregator Interface
      • Sample Usage of Aggregator
    • Dynamic Compact Serialization
  • Client Side ASP.NET Features
    • ASP.NET
      • ASP.NET Session State Provider for NCache
      • Multi-Region ASP.NET Session State Provider for NCache
    • ASP.NET Core
      • Session Storage in ASP.NET Core
        • Configure NCache ASP.NET Core Session Provider
        • Configure ASP.NET Core Sessions with NCache IDistributedCache Provider
      • Multi-Region ASP.NET Core Session Provider for NCache
      • Object Caching in ASP.NET Core
    • ASP.NET SignalR
      • Using NCache Extension for SignalR
    • View State Caching
      • Configuring and Using Content Optimization
      • Group View State with Sessions
      • Limit View State Caching
      • Perform Page Level Grouping for View State
    • ASP.NET Output Cache
      • Configure ASP.NET Output Caching
      • Using ASP.NET Output Cache with Custom Hooks
  • Client Side Third Party Integrations
    • Migrating AppFabric to NCache
      • AppFabric API vs. NCache API
    • NHibernate
      • NCache as NHibernate Second Level Cache
      • Using NHibernate Query Caching
      • Configuring Database Synchronization with NHibernate
    • Entity Framework Caching Integration
      • NCache as Entity Framework Second Level Cache
      • Entity Framework Caching Config File
    • Entity Framework Core Caching
      • Installing NCache Entity Framework Core Provider
      • Configuring NCache Entity Framework Core Provider
      • Using NCache Entity Framework Core Provider
        • Caching Options for EF Core Provider
        • LINQ APIs for EF Core Provider
        • Cache Only APIs for EF Core Provider
        • Query Deferred APIs for EF Core Provider
      • Logging in NCache Entity Framework Core Provider
    • Memcached
      • NCache Memcached Gateway Approach
      • Memcached Client Plugin for .NET
    • Debug NCache Providers in Visual Studio
    • NCache for Visual Studio Extension

Logging Entity Framework Core Caching Provider

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
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 ‘log-files’ directory in %NCHOME% 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 ‘log-files’ directory in %NCHOME% 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:

    1. Create custom implementation of the logging mechanism and provide instance of ILoggerFactory to the provider.

    2. 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)
        {
            LoggerFactory 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
    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();
        }
    }
    

    Back to top Copyright © 2017 Alachisoft