Add EFCacheKey to EFCacheableLogEvent

VahidN · VahidN · commit d6ebd2ca58a7 · 2024-12-10T08:54:01.000+03:30
diff --git a/src/EFCoreSecondLevelCacheInterceptor/DbCommandInterceptorProcessor.cs b/src/EFCoreSecondLevelCacheInterceptor/DbCommandInterceptorProcessor.cs
@@ -64,6 +64,8 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res
             return result;
         }
 
+        EFCacheKey? efCacheKey = null;
+
         try
         {
             if (!_cacheServiceCheck.IsCacheServiceAvailable())
@@ -84,14 +86,16 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res
                 {
                     var logMessage = $"Returning the cached TableRows[{rowsReader.TableName}].";
                     _interceptorProcessorLogger.LogDebug(CacheableEventId.CacheHit, logMessage);
-                    _logger.NotifyCacheableEvent(CacheableLogEventId.CacheHit, logMessage, command.CommandText);
+
+                    _logger.NotifyCacheableEvent(CacheableLogEventId.CacheHit, logMessage, command.CommandText,
+                        efCacheKey);
                 }
 
                 return result;
             }
 
             var commandText = command.CommandText;
-            var efCacheKey = _cacheKeyProvider.GetEFCacheKey(command, context, cachePolicy ?? new EFCachePolicy());
+            efCacheKey = _cacheKeyProvider.GetEFCacheKey(command, context, cachePolicy ?? new EFCachePolicy());
 
             if (_cacheDependenciesProcessor.InvalidateCacheDependencies(commandText, efCacheKey))
             {
@@ -104,7 +108,7 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res
                 {
                     var message = $"Skipping a none-cachable command[{commandText}].";
                     _interceptorProcessorLogger.LogDebug(message);
-                    _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);
+                    _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey);
                 }
 
                 return result;
@@ -123,7 +127,9 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res
                     {
                         var message = $"[{data}] added to the cache[{efCacheKey}].";
                         _interceptorProcessorLogger.LogDebug(CacheableEventId.QueryResultCached, message);
-                        _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText);
+
+                        _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText,
+                            efCacheKey);
                     }
                 }
 
@@ -150,7 +156,9 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res
                     {
                         var message = $"TableRows[{tableRows.TableName}] added to the cache[{efCacheKey}].";
                         _interceptorProcessorLogger.LogDebug(CacheableEventId.QueryResultCached, message);
-                        _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText);
+
+                        _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText,
+                            efCacheKey);
                     }
                 }
 
@@ -174,7 +182,9 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res
                     {
                         var message = $"[{result}] added to the cache[{efCacheKey}].";
                         _interceptorProcessorLogger.LogDebug(CacheableEventId.QueryResultCached, message);
-                        _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText);
+
+                        _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText,
+                            efCacheKey);
                     }
                 }
 
@@ -193,7 +203,9 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res
             if (_logger.IsLoggerEnabled)
             {
                 _interceptorProcessorLogger.LogCritical(ex, message: "Interceptor Error");
-                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, ex.ToString(), command.CommandText);
+
+                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, ex.ToString(), command.CommandText,
+                    efCacheKey);
             }
 
             return result;
@@ -210,6 +222,8 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re
             return result;
         }
 
+        EFCacheKey? efCacheKey = null;
+
         try
         {
             if (!_cacheServiceCheck.IsCacheServiceAvailable())
@@ -232,13 +246,13 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re
                 {
                     var message = $"Skipping a none-cachable command[{commandText}].";
                     _interceptorProcessorLogger.LogDebug(message);
-                    _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);
+                    _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey);
                 }
 
                 return result;
             }
 
-            var efCacheKey = _cacheKeyProvider.GetEFCacheKey(command, context, cachePolicy);
+            efCacheKey = _cacheKeyProvider.GetEFCacheKey(command, context, cachePolicy);
 
             if (_cacheService.GetValue(efCacheKey, cachePolicy) is not { } cacheResult)
             {
@@ -259,7 +273,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re
                     {
                         var message = "Suppressed the result with an empty TableRows.";
                         _interceptorProcessorLogger.LogDebug(message);
-                        _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText);
+
+                        _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText,
+                            efCacheKey);
                     }
 
                     using var rows = new EFTableRowsDataReader(new EFTableRows()
@@ -278,7 +294,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re
                         $"Suppressed the result with the TableRows[{cacheResult.TableRows.TableName}] from the cache[{efCacheKey}].";
 
                     _interceptorProcessorLogger.LogDebug(message);
-                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText);
+
+                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText,
+                        efCacheKey);
                 }
 
                 using var dataRows = new EFTableRowsDataReader(cacheResult.TableRows
@@ -299,7 +317,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re
                 {
                     var message = $"Suppressed the result with {cachedResult} from the cache[{efCacheKey}].";
                     _interceptorProcessorLogger.LogDebug(message);
-                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText);
+
+                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText,
+                        efCacheKey);
                 }
 
                 return (T)Convert.ChangeType(InterceptionResult<int>.SuppressWithResult(cachedResult), typeof(T),
@@ -314,7 +334,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re
                 {
                     var message = $"Suppressed the result with {cachedResult} from the cache[{efCacheKey}].";
                     _interceptorProcessorLogger.LogDebug(message);
-                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText);
+
+                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText,
+                        efCacheKey);
                 }
 
                 return (T)Convert.ChangeType(
@@ -326,7 +348,7 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re
             {
                 var message = $"Skipped the result with {result?.GetType()} type.";
                 _interceptorProcessorLogger.LogDebug(message);
-                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);
+                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey);
             }
 
             return result;
@@ -341,7 +363,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re
             if (_logger.IsLoggerEnabled)
             {
                 _interceptorProcessorLogger.LogCritical(ex, message: "Interceptor Error");
-                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, ex.ToString(), command.CommandText);
+
+                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, ex.ToString(), command.CommandText,
+                    efCacheKey);
             }
 
             return result;
@@ -396,7 +420,7 @@ private bool ShouldSkipCachingDbContext(DbContext context, string commandText)
         {
             var message = $"Skipped caching of this DbContext: {context.GetType()}";
             _interceptorProcessorLogger.LogDebug(message);
-            _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);
+            _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey: null);
         }
 
         return result;
@@ -421,7 +445,7 @@ private bool ShouldSkipCachingResults(string commandText, object value)
         {
             var message = "Skipped caching of this result based on the provided predicate.";
             _interceptorProcessorLogger.LogDebug(message);
-            _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);
+            _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey: null);
         }
 
         return result;
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCacheDependenciesProcessor.cs b/src/EFCoreSecondLevelCacheInterceptor/EFCacheDependenciesProcessor.cs
@@ -95,7 +95,7 @@ public SortedSet<string> GetCacheDependencies(EFCachePolicy cachePolicy,
                     $"It's not possible to calculate the related table names of the current query[{commandText}]. Please use EFCachePolicy.Configure(options => options.CacheDependencies(\"real_table_name_1\", \"real_table_name_2\")) to specify them explicitly.";
 
                 _dependenciesProcessorLogger.LogDebug(message);
-                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, message, commandText);
+                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, message, commandText, efCacheKey: null);
             }
 
             cacheDependencies = new SortedSet<string>(StringComparer.OrdinalIgnoreCase)
@@ -125,7 +125,7 @@ public bool InvalidateCacheDependencies(string commandText, EFCacheKey cacheKey)
             {
                 var message = $"Skipped invalidating a none-CRUD command[{commandText}].";
                 _dependenciesProcessorLogger.LogDebug(message);
-                _logger.NotifyCacheableEvent(CacheableLogEventId.InvalidationSkipped, message, commandText);
+                _logger.NotifyCacheableEvent(CacheableLogEventId.InvalidationSkipped, message, commandText, cacheKey);
             }
 
             return false;
@@ -139,7 +139,7 @@ public bool InvalidateCacheDependencies(string commandText, EFCacheKey cacheKey)
                     $"Skipped invalidating the related cache entries of this query[{commandText}] based on the provided predicate.";
 
                 _dependenciesProcessorLogger.LogDebug(message);
-                _logger.NotifyCacheableEvent(CacheableLogEventId.InvalidationSkipped, message, commandText);
+                _logger.NotifyCacheableEvent(CacheableLogEventId.InvalidationSkipped, message, commandText, cacheKey);
             }
 
             return false;
@@ -153,7 +153,7 @@ public bool InvalidateCacheDependencies(string commandText, EFCacheKey cacheKey)
         {
             var message = $"Invalidated [{string.Join(separator: ", ", cacheKey.CacheDependencies)}] dependencies.";
             _dependenciesProcessorLogger.LogDebug(CacheableEventId.QueryResultInvalidated, message);
-            _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText);
+            _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText, cacheKey);
         }
 
         _logger.NotifyCacheInvalidation(clearAllCachedEntries: false, cacheKey.CacheDependencies);
@@ -179,7 +179,9 @@ private void LogProcess(SortedSet<string> tableNames,
                 $"ContextTableNames: {names}, PossibleQueryTableNames: {texts} -> CacheDependencies: {dependencies}.";
 
             _dependenciesProcessorLogger.LogDebug(message);
-            _logger.NotifyCacheableEvent(CacheableLogEventId.CacheDependenciesCalculated, message, commandText);
+
+            _logger.NotifyCacheableEvent(CacheableLogEventId.CacheDependenciesCalculated, message, commandText,
+                efCacheKey: null);
         }
     }
 
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCacheManagerCoreProvider.cs b/src/EFCoreSecondLevelCacheInterceptor/EFCacheManagerCoreProvider.cs
@@ -143,7 +143,9 @@ public void InvalidateCacheDependencies(EFCacheKey cacheKey)
                         $"Invalidated all of the cache entries due to early expiration of a root cache key[{rootCacheKey}].";
 
                     _cacheManagerCoreProviderLogger.LogDebug(CacheableEventId.QueryResultInvalidated, message);
-                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText: "");
+
+                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText: "",
+                        cacheKey);
                 }
 
                 ClearAllCachedEntries();
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCachePolicyParser.cs b/src/EFCoreSecondLevelCacheInterceptor/EFCachePolicyParser.cs
@@ -131,7 +131,9 @@ public string RemoveEFCachePolicyTag(string commandText)
         {
             var message = $"Using EFCachePolicy: {efCachePolicy}.";
             _policyParserLogger.LogDebug(message: "Using EFCachePolicy: {EfCachePolicy}.", efCachePolicy);
-            _logger.NotifyCacheableEvent(CacheableLogEventId.CachePolicyCalculated, message, commandText);
+
+            _logger.NotifyCacheableEvent(CacheableLogEventId.CachePolicyCalculated, message, commandText,
+                efCacheKey: null);
         }
 
         return efCachePolicy;
@@ -145,7 +147,7 @@ private bool ShouldSkipCachingCommands(string commandText)
         {
             var message = $"Skipped caching of this command[{commandText}] based on the provided predicate.";
             _policyParserLogger.LogDebug(message);
-            _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);
+            _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey: null);
         }
 
         return result;
@@ -446,7 +448,9 @@ private bool ContainsNonDeterministicFunction(string commandText)
             {
                 var message = $"Skipped caching because of the non-deterministic function -> `{item}`.";
                 _policyParserLogger.LogDebug(message);
-                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);
+
+                _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText,
+                    efCacheKey: null);
             }
 
             return hasFn;
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCacheableLogEvent.cs b/src/EFCoreSecondLevelCacheInterceptor/EFCacheableLogEvent.cs
@@ -22,6 +22,11 @@ public class EFCacheableLogEvent
     /// </summary>
     public string CommandText { set; get; } = default!;
 
+    /// <summary>
+    ///     Stores information of the computed key of the input LINQ query.
+    /// </summary>
+    public EFCacheKey? EFCacheKey { set; get; }
+
     /// <summary>
     ///     Defines a mechanism for retrieving a service object.
     ///     For instance, you can create an ILoggerFactory by using it.
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCoreSecondLevelCacheInterceptor.csproj b/src/EFCoreSecondLevelCacheInterceptor/EFCoreSecondLevelCacheInterceptor.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <Description>Entity Framework Core Second Level Caching Library.</Description>
-        <VersionPrefix>4.8.8</VersionPrefix>
+        <VersionPrefix>4.9.0</VersionPrefix>
         <Authors>Vahid Nasiri</Authors>
         <TargetFrameworks>net9.0;net8.0;net7.0;net6.0;net5.0;netstandard2.1;netstandard2.0;net462;netcoreapp3.1;</TargetFrameworks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFDebugLogger.cs b/src/EFCoreSecondLevelCacheInterceptor/EFDebugLogger.cs
@@ -42,7 +42,7 @@ public EFDebugLogger(IOptions<EFCoreSecondLevelCacheSettings> cacheSettings,
         {
             var message = $"InstanceId: {Guid.NewGuid()}, Started @{DateTime.UtcNow} UTC.";
             logger.LogDebug(message);
-            NotifyCacheableEvent(CacheableLogEventId.CachingSystemStarted, message, commandText: "");
+            NotifyCacheableEvent(CacheableLogEventId.CachingSystemStarted, message, commandText: "", efCacheKey: null);
         }
     }
 
@@ -54,7 +54,10 @@ public EFDebugLogger(IOptions<EFCoreSecondLevelCacheSettings> cacheSettings,
     /// <summary>
     ///     If you set DisableLogging to false, this delegate will give you the internal caching events of the library.
     /// </summary>
-    public void NotifyCacheableEvent(CacheableLogEventId eventId, string message, string commandText)
+    public void NotifyCacheableEvent(CacheableLogEventId eventId,
+        string message,
+        string commandText,
+        EFCacheKey? efCacheKey)
     {
         if (IsLoggerEnabled && _cacheableEvent is not null)
         {
@@ -63,6 +66,7 @@ public void NotifyCacheableEvent(CacheableLogEventId eventId, string message, st
                 EventId = eventId,
                 Message = message,
                 CommandText = commandText,
+                EFCacheKey = efCacheKey,
                 ServiceProvider = _serviceProvider
             });
         }
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFEasyCachingCoreProvider.cs b/src/EFCoreSecondLevelCacheInterceptor/EFEasyCachingCoreProvider.cs
@@ -158,7 +158,9 @@ public void InvalidateCacheDependencies(EFCacheKey cacheKey)
                         $"Invalidated all of the cache entries due to early expiration of a root cache key[{rootCacheKey}].";
 
                     _easyCachingCoreProviderLogger.LogDebug(CacheableEventId.QueryResultInvalidated, message);
-                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText: "");
+
+                    _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText: "",
+                        cacheKey);
                 }
 
                 ClearAllCachedEntries();
diff --git a/src/EFCoreSecondLevelCacheInterceptor/IEFDebugLogger.cs b/src/EFCoreSecondLevelCacheInterceptor/IEFDebugLogger.cs
@@ -15,7 +15,7 @@ public interface IEFDebugLogger
     /// <summary>
     ///     If you set DisableLogging to false, this delegate will give you the internal caching events of the library.
     /// </summary>
-    void NotifyCacheableEvent(CacheableLogEventId eventId, string message, string commandText);
+    void NotifyCacheableEvent(CacheableLogEventId eventId, string message, string commandText, EFCacheKey? efCacheKey);
 
     /// <summary>
     ///     Represents some information about the current cache invalidation event
diff --git a/src/Tests/EFCoreSecondLevelCacheInterceptor.UnitTests/DbCommandInterceptorProcessorTests.cs b/src/Tests/EFCoreSecondLevelCacheInterceptor.UnitTests/DbCommandInterceptorProcessorTests.cs
diff --git a/src/Tests/EFCoreSecondLevelCacheInterceptor.UnitTests/EFDebugLoggerTests.cs b/src/Tests/EFCoreSecondLevelCacheInterceptor.UnitTests/EFDebugLoggerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,8 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res`
`64`	`64`	`return result;`
`65`	`65`	`}`
`66`	`66`
	`67`	`+ EFCacheKey? efCacheKey = null;`
	`68`	`+`
`67`	`69`	`try`
`68`	`70`	`{`
`69`	`71`	`if (!_cacheServiceCheck.IsCacheServiceAvailable())`
`@@ -84,14 +86,16 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res`
`84`	`86`	`{`
`85`	`87`	`var logMessage = $"Returning the cached TableRows[{rowsReader.TableName}].";`
`86`	`88`	`_interceptorProcessorLogger.LogDebug(CacheableEventId.CacheHit, logMessage);`
`87`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CacheHit, logMessage, command.CommandText);`
	`89`	`+`
	`90`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CacheHit, logMessage, command.CommandText,`
	`91`	`+ efCacheKey);`
`88`	`92`	`}`
`89`	`93`
`90`	`94`	`return result;`
`91`	`95`	`}`
`92`	`96`
`93`	`97`	`var commandText = command.CommandText;`
`94`		`- var efCacheKey = _cacheKeyProvider.GetEFCacheKey(command, context, cachePolicy ?? new EFCachePolicy());`
	`98`	`+ efCacheKey = _cacheKeyProvider.GetEFCacheKey(command, context, cachePolicy ?? new EFCachePolicy());`
`95`	`99`
`96`	`100`	`if (_cacheDependenciesProcessor.InvalidateCacheDependencies(commandText, efCacheKey))`
`97`	`101`	`{`
`@@ -104,7 +108,7 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res`
`104`	`108`	`{`
`105`	`109`	`var message = $"Skipping a none-cachable command[{commandText}].";`
`106`	`110`	`_interceptorProcessorLogger.LogDebug(message);`
`107`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);`
	`111`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey);`
`108`	`112`	`}`
`109`	`113`
`110`	`114`	`return result;`
`@@ -123,7 +127,9 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res`
`123`	`127`	`{`
`124`	`128`	`var message = $"[{data}] added to the cache[{efCacheKey}].";`
`125`	`129`	`_interceptorProcessorLogger.LogDebug(CacheableEventId.QueryResultCached, message);`
`126`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText);`
	`130`	`+`
	`131`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText,`
	`132`	`+ efCacheKey);`
`127`	`133`	`}`
`128`	`134`	`}`
`129`	`135`
`@@ -150,7 +156,9 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res`
`150`	`156`	`{`
`151`	`157`	`var message = $"TableRows[{tableRows.TableName}] added to the cache[{efCacheKey}].";`
`152`	`158`	`_interceptorProcessorLogger.LogDebug(CacheableEventId.QueryResultCached, message);`
`153`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText);`
	`159`	`+`
	`160`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText,`
	`161`	`+ efCacheKey);`
`154`	`162`	`}`
`155`	`163`	`}`
`156`	`164`
`@@ -174,7 +182,9 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res`
`174`	`182`	`{`
`175`	`183`	`var message = $"[{result}] added to the cache[{efCacheKey}].";`
`176`	`184`	`_interceptorProcessorLogger.LogDebug(CacheableEventId.QueryResultCached, message);`
`177`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText);`
	`185`	`+`
	`186`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultCached, message, commandText,`
	`187`	`+ efCacheKey);`
`178`	`188`	`}`
`179`	`189`	`}`
`180`	`190`
`@@ -193,7 +203,9 @@ public T ProcessExecutedCommands<T>(DbCommand command, DbContext? context, T res`
`193`	`203`	`if (_logger.IsLoggerEnabled)`
`194`	`204`	`{`
`195`	`205`	`_interceptorProcessorLogger.LogCritical(ex, message: "Interceptor Error");`
`196`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, ex.ToString(), command.CommandText);`
	`206`	`+`
	`207`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, ex.ToString(), command.CommandText,`
	`208`	`+ efCacheKey);`
`197`	`209`	`}`
`198`	`210`
`199`	`211`	`return result;`
`@@ -210,6 +222,8 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re`
`210`	`222`	`return result;`
`211`	`223`	`}`
`212`	`224`
	`225`	`+ EFCacheKey? efCacheKey = null;`
	`226`	`+`
`213`	`227`	`try`
`214`	`228`	`{`
`215`	`229`	`if (!_cacheServiceCheck.IsCacheServiceAvailable())`
`@@ -232,13 +246,13 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re`
`232`	`246`	`{`
`233`	`247`	`var message = $"Skipping a none-cachable command[{commandText}].";`
`234`	`248`	`_interceptorProcessorLogger.LogDebug(message);`
`235`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);`
	`249`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey);`
`236`	`250`	`}`
`237`	`251`
`238`	`252`	`return result;`
`239`	`253`	`}`
`240`	`254`
`241`		`- var efCacheKey = _cacheKeyProvider.GetEFCacheKey(command, context, cachePolicy);`
	`255`	`+ efCacheKey = _cacheKeyProvider.GetEFCacheKey(command, context, cachePolicy);`
`242`	`256`
`243`	`257`	`if (_cacheService.GetValue(efCacheKey, cachePolicy) is not { } cacheResult)`
`244`	`258`	`{`
`@@ -259,7 +273,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re`
`259`	`273`	`{`
`260`	`274`	`var message = "Suppressed the result with an empty TableRows.";`
`261`	`275`	`_interceptorProcessorLogger.LogDebug(message);`
`262`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText);`
	`276`	`+`
	`277`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText,`
	`278`	`+ efCacheKey);`
`263`	`279`	`}`
`264`	`280`
`265`	`281`	`using var rows = new EFTableRowsDataReader(new EFTableRows()`
`@@ -278,7 +294,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re`
`278`	`294`	`$"Suppressed the result with the TableRows[{cacheResult.TableRows.TableName}] from the cache[{efCacheKey}].";`
`279`	`295`
`280`	`296`	`_interceptorProcessorLogger.LogDebug(message);`
`281`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText);`
	`297`	`+`
	`298`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText,`
	`299`	`+ efCacheKey);`
`282`	`300`	`}`
`283`	`301`
`284`	`302`	`using var dataRows = new EFTableRowsDataReader(cacheResult.TableRows`
`@@ -299,7 +317,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re`
`299`	`317`	`{`
`300`	`318`	`var message = $"Suppressed the result with {cachedResult} from the cache[{efCacheKey}].";`
`301`	`319`	`_interceptorProcessorLogger.LogDebug(message);`
`302`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText);`
	`320`	`+`
	`321`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText,`
	`322`	`+ efCacheKey);`
`303`	`323`	`}`
`304`	`324`
`305`	`325`	`return (T)Convert.ChangeType(InterceptionResult<int>.SuppressWithResult(cachedResult), typeof(T),`
`@@ -314,7 +334,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re`
`314`	`334`	`{`
`315`	`335`	`var message = $"Suppressed the result with {cachedResult} from the cache[{efCacheKey}].";`
`316`	`336`	`_interceptorProcessorLogger.LogDebug(message);`
`317`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText);`
	`337`	`+`
	`338`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultSuppressed, message, commandText,`
	`339`	`+ efCacheKey);`
`318`	`340`	`}`
`319`	`341`
`320`	`342`	`return (T)Convert.ChangeType(`
`@@ -326,7 +348,7 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re`
`326`	`348`	`{`
`327`	`349`	`var message = $"Skipped the result with {result?.GetType()} type.";`
`328`	`350`	`_interceptorProcessorLogger.LogDebug(message);`
`329`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);`
	`351`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey);`
`330`	`352`	`}`
`331`	`353`
`332`	`354`	`return result;`
`@@ -341,7 +363,9 @@ public T ProcessExecutingCommands<T>(DbCommand command, DbContext? context, T re`
`341`	`363`	`if (_logger.IsLoggerEnabled)`
`342`	`364`	`{`
`343`	`365`	`_interceptorProcessorLogger.LogCritical(ex, message: "Interceptor Error");`
`344`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, ex.ToString(), command.CommandText);`
	`366`	`+`
	`367`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, ex.ToString(), command.CommandText,`
	`368`	`+ efCacheKey);`
`345`	`369`	`}`
`346`	`370`
`347`	`371`	`return result;`
`@@ -396,7 +420,7 @@ private bool ShouldSkipCachingDbContext(DbContext context, string commandText)`
`396`	`420`	`{`
`397`	`421`	`var message = $"Skipped caching of this DbContext: {context.GetType()}";`
`398`	`422`	`_interceptorProcessorLogger.LogDebug(message);`
`399`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);`
	`423`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey: null);`
`400`	`424`	`}`
`401`	`425`
`402`	`426`	`return result;`
`@@ -421,7 +445,7 @@ private bool ShouldSkipCachingResults(string commandText, object value)`
`421`	`445`	`{`
`422`	`446`	`var message = "Skipped caching of this result based on the provided predicate.";`
`423`	`447`	`_interceptorProcessorLogger.LogDebug(message);`
`424`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);`
	`448`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey: null);`
`425`	`449`	`}`
`426`	`450`
`427`	`451`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ public SortedSet<string> GetCacheDependencies(EFCachePolicy cachePolicy,`
`95`	`95`	`$"It's not possible to calculate the related table names of the current query[{commandText}]. Please use EFCachePolicy.Configure(options => options.CacheDependencies(\"real_table_name_1\", \"real_table_name_2\")) to specify them explicitly.";`
`96`	`96`
`97`	`97`	`_dependenciesProcessorLogger.LogDebug(message);`
`98`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, message, commandText);`
	`98`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingError, message, commandText, efCacheKey: null);`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`cacheDependencies = new SortedSet<string>(StringComparer.OrdinalIgnoreCase)`
`@@ -125,7 +125,7 @@ public bool InvalidateCacheDependencies(string commandText, EFCacheKey cacheKey)`
`125`	`125`	`{`
`126`	`126`	`var message = $"Skipped invalidating a none-CRUD command[{commandText}].";`
`127`	`127`	`_dependenciesProcessorLogger.LogDebug(message);`
`128`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.InvalidationSkipped, message, commandText);`
	`128`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.InvalidationSkipped, message, commandText, cacheKey);`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`return false;`
`@@ -139,7 +139,7 @@ public bool InvalidateCacheDependencies(string commandText, EFCacheKey cacheKey)`
`139`	`139`	`$"Skipped invalidating the related cache entries of this query[{commandText}] based on the provided predicate.";`
`140`	`140`
`141`	`141`	`_dependenciesProcessorLogger.LogDebug(message);`
`142`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.InvalidationSkipped, message, commandText);`
	`142`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.InvalidationSkipped, message, commandText, cacheKey);`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`return false;`
`@@ -153,7 +153,7 @@ public bool InvalidateCacheDependencies(string commandText, EFCacheKey cacheKey)`
`153`	`153`	`{`
`154`	`154`	`var message = $"Invalidated [{string.Join(separator: ", ", cacheKey.CacheDependencies)}] dependencies.";`
`155`	`155`	`_dependenciesProcessorLogger.LogDebug(CacheableEventId.QueryResultInvalidated, message);`
`156`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText);`
	`156`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText, cacheKey);`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`_logger.NotifyCacheInvalidation(clearAllCachedEntries: false, cacheKey.CacheDependencies);`
`@@ -179,7 +179,9 @@ private void LogProcess(SortedSet<string> tableNames,`
`179`	`179`	`$"ContextTableNames: {names}, PossibleQueryTableNames: {texts} -> CacheDependencies: {dependencies}.";`
`180`	`180`
`181`	`181`	`_dependenciesProcessorLogger.LogDebug(message);`
`182`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CacheDependenciesCalculated, message, commandText);`
	`182`	`+`
	`183`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CacheDependenciesCalculated, message, commandText,`
	`184`	`+ efCacheKey: null);`
`183`	`185`	`}`
`184`	`186`	`}`
`185`	`187`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,9 @@ public void InvalidateCacheDependencies(EFCacheKey cacheKey)`
`143`	`143`	`$"Invalidated all of the cache entries due to early expiration of a root cache key[{rootCacheKey}].";`
`144`	`144`
`145`	`145`	`_cacheManagerCoreProviderLogger.LogDebug(CacheableEventId.QueryResultInvalidated, message);`
`146`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText: "");`
	`146`	`+`
	`147`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText: "",`
	`148`	`+ cacheKey);`
`147`	`149`	`}`
`148`	`150`
`149`	`151`	`ClearAllCachedEntries();`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,9 @@ public string RemoveEFCachePolicyTag(string commandText)`
`131`	`131`	`{`
`132`	`132`	`var message = $"Using EFCachePolicy: {efCachePolicy}.";`
`133`	`133`	`_policyParserLogger.LogDebug(message: "Using EFCachePolicy: {EfCachePolicy}.", efCachePolicy);`
`134`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachePolicyCalculated, message, commandText);`
	`134`	`+`
	`135`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachePolicyCalculated, message, commandText,`
	`136`	`+ efCacheKey: null);`
`135`	`137`	`}`
`136`	`138`
`137`	`139`	`return efCachePolicy;`
`@@ -145,7 +147,7 @@ private bool ShouldSkipCachingCommands(string commandText)`
`145`	`147`	`{`
`146`	`148`	`var message = $"Skipped caching of this command[{commandText}] based on the provided predicate.";`
`147`	`149`	`_policyParserLogger.LogDebug(message);`
`148`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);`
	`150`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText, efCacheKey: null);`
`149`	`151`	`}`
`150`	`152`
`151`	`153`	`return result;`
`@@ -446,7 +448,9 @@ private bool ContainsNonDeterministicFunction(string commandText)`
`446`	`448`	`{`
`447`	`449`	var message = $"Skipped caching because of the non-deterministic function -> `{item}`.";
`448`	`450`	`_policyParserLogger.LogDebug(message);`
`449`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText);`
	`451`	`+`
	`452`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.CachingSkipped, message, commandText,`
	`453`	`+ efCacheKey: null);`
`450`	`454`	`}`
`451`	`455`
`452`	`456`	`return hasFn;`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public EFDebugLogger(IOptions<EFCoreSecondLevelCacheSettings> cacheSettings,`
`42`	`42`	`{`
`43`	`43`	`var message = $"InstanceId: {Guid.NewGuid()}, Started @{DateTime.UtcNow} UTC.";`
`44`	`44`	`logger.LogDebug(message);`
`45`		`- NotifyCacheableEvent(CacheableLogEventId.CachingSystemStarted, message, commandText: "");`
	`45`	`+ NotifyCacheableEvent(CacheableLogEventId.CachingSystemStarted, message, commandText: "", efCacheKey: null);`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`@@ -54,7 +54,10 @@ public EFDebugLogger(IOptions<EFCoreSecondLevelCacheSettings> cacheSettings,`
`54`	`54`	`/// <summary>`
`55`	`55`	`/// If you set DisableLogging to false, this delegate will give you the internal caching events of the library.`
`56`	`56`	`/// </summary>`
`57`		`- public void NotifyCacheableEvent(CacheableLogEventId eventId, string message, string commandText)`
	`57`	`+ public void NotifyCacheableEvent(CacheableLogEventId eventId,`
	`58`	`+ string message,`
	`59`	`+ string commandText,`
	`60`	`+ EFCacheKey? efCacheKey)`
`58`	`61`	`{`
`59`	`62`	`if (IsLoggerEnabled && _cacheableEvent is not null)`
`60`	`63`	`{`
`@@ -63,6 +66,7 @@ public void NotifyCacheableEvent(CacheableLogEventId eventId, string message, st`
`63`	`66`	`EventId = eventId,`
`64`	`67`	`Message = message,`
`65`	`68`	`CommandText = commandText,`
	`69`	`+ EFCacheKey = efCacheKey,`
`66`	`70`	`ServiceProvider = _serviceProvider`
`67`	`71`	`});`
`68`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,9 @@ public void InvalidateCacheDependencies(EFCacheKey cacheKey)`
`158`	`158`	`$"Invalidated all of the cache entries due to early expiration of a root cache key[{rootCacheKey}].";`
`159`	`159`
`160`	`160`	`_easyCachingCoreProviderLogger.LogDebug(CacheableEventId.QueryResultInvalidated, message);`
`161`		`- _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText: "");`
	`161`	`+`
	`162`	`+ _logger.NotifyCacheableEvent(CacheableLogEventId.QueryResultInvalidated, message, commandText: "",`
	`163`	`+ cacheKey);`
`162`	`164`	`}`
`163`	`165`
`164`	`166`	`ClearAllCachedEntries();`