From 088af92fd052a05ff691c8b730a6649793274925 Mon Sep 17 00:00:00 2001
From: Sebastian <sebastian@squidex.io>
Date: Wed, 30 Dec 2020 23:41:39 +0100
Subject: [PATCH] Consistent cache keys

---
 .../HandleRules/EventEnricher.cs              |  8 ++---
 .../Scripting/Internal/Parser.cs              | 29 +++++++------------
 .../Scripting/JintScriptEngine.cs             |  4 +--
 .../Apps/Indexes/AppsIndex.cs                 | 21 +++++++-------
 .../Rules/RuleEnqueuer.cs                     |  4 ++-
 .../Schemas/Indexes/SchemasIndex.cs           | 21 +++++++-------
 .../UsageTracking/CachingUsageTracker.cs      |  4 +--
 7 files changed, 42 insertions(+), 49 deletions(-)

diff --git a/backend/src/Squidex.Domain.Apps.Core.Operations/HandleRules/EventEnricher.cs b/backend/src/Squidex.Domain.Apps.Core.Operations/HandleRules/EventEnricher.cs
index 221ac18f8..29688c57d 100644
--- a/backend/src/Squidex.Domain.Apps.Core.Operations/HandleRules/EventEnricher.cs
+++ b/backend/src/Squidex.Domain.Apps.Core.Operations/HandleRules/EventEnricher.cs
@@ -18,7 +18,7 @@ namespace Squidex.Domain.Apps.Core.HandleRules
 {
     public sealed class EventEnricher : IEventEnricher
     {
-        private static readonly TimeSpan UserCacheDuration = TimeSpan.FromMinutes(10);
+        private static readonly TimeSpan CacheDuration = TimeSpan.FromMinutes(10);
         private readonly IMemoryCache userCache;
         private readonly IUserResolver userResolver;
 
@@ -56,11 +56,11 @@ namespace Squidex.Domain.Apps.Core.HandleRules
 
         private Task<IUser?> FindUserAsync(RefToken actor)
         {
-            var key = $"EventEnrichers_Users_{actor.Identifier}";
+            var cacheKey = $"{typeof(EventEnricher)}_Users_{actor.Identifier}";
 
-            return userCache.GetOrCreateAsync(key, async x =>
+            return userCache.GetOrCreateAsync(cacheKey, async x =>
             {
-                x.AbsoluteExpirationRelativeToNow = UserCacheDuration;
+                x.AbsoluteExpirationRelativeToNow = CacheDuration;
 
                 IUser? user;
                 try
diff --git a/backend/src/Squidex.Domain.Apps.Core.Operations/Scripting/Internal/Parser.cs b/backend/src/Squidex.Domain.Apps.Core.Operations/Scripting/Internal/Parser.cs
index b2d3087f5..0e01d4153 100644
--- a/backend/src/Squidex.Domain.Apps.Core.Operations/Scripting/Internal/Parser.cs
+++ b/backend/src/Squidex.Domain.Apps.Core.Operations/Scripting/Internal/Parser.cs
@@ -15,40 +15,33 @@ namespace Squidex.Domain.Apps.Core.Scripting.Internal
 {
     internal sealed class Parser
     {
-        private static readonly TimeSpan Expiration = TimeSpan.FromMinutes(10);
+        private static readonly TimeSpan CacheDuration = TimeSpan.FromMinutes(10);
         private static readonly ParserOptions DefaultParserOptions = new ParserOptions
         {
             AdaptRegexp = true, Tolerant = true, Loc = true
         };
 
-        private readonly IMemoryCache memoryCache;
+        private readonly IMemoryCache cache;
 
-        public Parser(IMemoryCache memoryCache)
+        public Parser(IMemoryCache cache)
         {
-            Guard.NotNull(memoryCache, nameof(memoryCache));
+            Guard.NotNull(cache, nameof(cache));
 
-            this.memoryCache = memoryCache;
+            this.cache = cache;
         }
 
         public Script Parse(string script)
         {
-            var key = Key(script);
+            var cacheKey = $"{typeof(Parser)}_Script_{script}";
 
-            if (!memoryCache.TryGetValue<Script>(key, out var compiledScript))
+            return cache.GetOrCreate(cacheKey, entry =>
             {
-                var parser = new JavaScriptParser(script, DefaultParserOptions);
-
-                compiledScript = parser.ParseScript();
-
-                memoryCache.Set(key, compiledScript, Expiration);
-            }
+                entry.AbsoluteExpirationRelativeToNow = CacheDuration;
 
-            return compiledScript;
-        }
+                var parser = new JavaScriptParser(script, DefaultParserOptions);
 
-        private static string Key(string script)
-        {
-            return $"SCRIPT_{script}";
+                return parser.ParseScript();
+            });
         }
     }
 }
diff --git a/backend/src/Squidex.Domain.Apps.Core.Operations/Scripting/JintScriptEngine.cs b/backend/src/Squidex.Domain.Apps.Core.Operations/Scripting/JintScriptEngine.cs
index aa083097d..04d60fe36 100644
--- a/backend/src/Squidex.Domain.Apps.Core.Operations/Scripting/JintScriptEngine.cs
+++ b/backend/src/Squidex.Domain.Apps.Core.Operations/Scripting/JintScriptEngine.cs
@@ -34,9 +34,9 @@ namespace Squidex.Domain.Apps.Core.Scripting
 
         public TimeSpan TimeoutExecution { get; set; } = TimeSpan.FromMilliseconds(4000);
 
-        public JintScriptEngine(IMemoryCache memoryCache, IEnumerable<IJintExtension>? extensions = null)
+        public JintScriptEngine(IMemoryCache cache, IEnumerable<IJintExtension>? extensions = null)
         {
-            parser = new Parser(memoryCache);
+            parser = new Parser(cache);
 
             this.extensions = extensions?.ToArray() ?? Array.Empty<IJintExtension>();
         }
diff --git a/backend/src/Squidex.Domain.Apps.Entities/Apps/Indexes/AppsIndex.cs b/backend/src/Squidex.Domain.Apps.Entities/Apps/Indexes/AppsIndex.cs
index 9c2235935..2f22630da 100644
--- a/backend/src/Squidex.Domain.Apps.Entities/Apps/Indexes/AppsIndex.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Apps/Indexes/AppsIndex.cs
@@ -29,16 +29,15 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes
     {
         private static readonly TimeSpan CacheDuration = TimeSpan.FromMinutes(5);
         private readonly IGrainFactory grainFactory;
-        private readonly IReplicatedCache replicatedCache;
+        private readonly IReplicatedCache grainCache;
 
-        public AppsIndex(IGrainFactory grainFactory, IReplicatedCache replicatedCache)
+        public AppsIndex(IGrainFactory grainFactory, IReplicatedCache grainCache)
         {
             Guard.NotNull(grainFactory, nameof(grainFactory));
-            Guard.NotNull(replicatedCache, nameof(replicatedCache));
+            Guard.NotNull(grainCache, nameof(grainCache));
 
             this.grainFactory = grainFactory;
-
-            this.replicatedCache = replicatedCache;
+            this.grainCache = grainCache;
         }
 
         public async Task RebuildByContributorsAsync(DomainId appId, HashSet<string> contributors)
@@ -117,7 +116,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes
             {
                 if (canCache)
                 {
-                    if (replicatedCache.TryGetValue(GetCacheKey(name), out var v) && v is IAppEntity cacheApp)
+                    if (grainCache.TryGetValue(GetCacheKey(name), out var v) && v is IAppEntity cacheApp)
                     {
                         return cacheApp;
                     }
@@ -140,7 +139,7 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes
             {
                 if (canCache)
                 {
-                    if (replicatedCache.TryGetValue(GetCacheKey(appId), out var v) && v is IAppEntity cachedApp)
+                    if (grainCache.TryGetValue(GetCacheKey(appId), out var v) && v is IAppEntity cachedApp)
                     {
                         return cachedApp;
                     }
@@ -312,19 +311,19 @@ namespace Squidex.Domain.Apps.Entities.Apps.Indexes
 
         private static string GetCacheKey(DomainId id)
         {
-            return $"APPS_ID_{id}";
+            return $"{typeof(AppsIndex)}_Apps_Id_{id}";
         }
 
         private static string GetCacheKey(string name)
         {
-            return $"APPS_NAME_{name}";
+            return $"{typeof(AppsIndex)}_Apps_Name_{name}";
         }
 
         private Task CacheItAsync(IAppEntity app, bool publish)
         {
             return Task.WhenAll(
-                replicatedCache.AddAsync(GetCacheKey(app.Id), app, CacheDuration, publish),
-                replicatedCache.AddAsync(GetCacheKey(app.Name), app, CacheDuration, publish));
+                grainCache.AddAsync(GetCacheKey(app.Id), app, CacheDuration, publish),
+                grainCache.AddAsync(GetCacheKey(app.Name), app, CacheDuration, publish));
         }
     }
 }
diff --git a/backend/src/Squidex.Domain.Apps.Entities/Rules/RuleEnqueuer.cs b/backend/src/Squidex.Domain.Apps.Entities/Rules/RuleEnqueuer.cs
index 344f39f44..6892df1c2 100644
--- a/backend/src/Squidex.Domain.Apps.Entities/Rules/RuleEnqueuer.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Rules/RuleEnqueuer.cs
@@ -82,7 +82,9 @@ namespace Squidex.Domain.Apps.Entities.Rules
 
         private Task<List<IRuleEntity>> GetRulesAsync(DomainId appId)
         {
-            return cache.GetOrCreateAsync(appId, entry =>
+            var cacheKey = $"{typeof(RuleEnqueuer)}_Rules_{appId}";
+
+            return cache.GetOrCreateAsync(cacheKey, entry =>
             {
                 entry.AbsoluteExpirationRelativeToNow = CacheDuration;
 
diff --git a/backend/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasIndex.cs b/backend/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasIndex.cs
index 7ac5e503d..14920ee86 100644
--- a/backend/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasIndex.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities/Schemas/Indexes/SchemasIndex.cs
@@ -26,16 +26,15 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes
     {
         private static readonly TimeSpan CacheDuration = TimeSpan.FromMinutes(5);
         private readonly IGrainFactory grainFactory;
-        private readonly IReplicatedCache replicatedCache;
+        private readonly IReplicatedCache grainCache;
 
-        public SchemasIndex(IGrainFactory grainFactory, IReplicatedCache replicatedCache)
+        public SchemasIndex(IGrainFactory grainFactory, IReplicatedCache grainCache)
         {
             Guard.NotNull(grainFactory, nameof(grainFactory));
-            Guard.NotNull(replicatedCache, nameof(replicatedCache));
+            Guard.NotNull(grainCache, nameof(grainCache));
 
             this.grainFactory = grainFactory;
-
-            this.replicatedCache = replicatedCache;
+            this.grainCache = grainCache;
         }
 
         public Task RebuildAsync(DomainId appId, Dictionary<string, DomainId> schemas)
@@ -65,7 +64,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes
 
                 if (canCache)
                 {
-                    if (replicatedCache.TryGetValue(cacheKey, out var v) && v is ISchemaEntity cachedSchema)
+                    if (grainCache.TryGetValue(cacheKey, out var v) && v is ISchemaEntity cachedSchema)
                     {
                         return cachedSchema;
                     }
@@ -90,7 +89,7 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes
 
                 if (canCache)
                 {
-                    if (replicatedCache.TryGetValue(cacheKey, out var v) && v is ISchemaEntity cachedSchema)
+                    if (grainCache.TryGetValue(cacheKey, out var v) && v is ISchemaEntity cachedSchema)
                     {
                         return cachedSchema;
                     }
@@ -214,19 +213,19 @@ namespace Squidex.Domain.Apps.Entities.Schemas.Indexes
 
         private static string GetCacheKey(DomainId appId, string name)
         {
-            return $"SCHEMAS_NAME_{appId}_{name}";
+            return $"{typeof(SchemasIndex)}_Schemas_Name_{appId}_{name}";
         }
 
         private static string GetCacheKey(DomainId appId, DomainId id)
         {
-            return $"SCHEMAS_ID_{appId}_{id}";
+            return $"{typeof(SchemasIndex)}_Schemas_Id_{appId}_{id}";
         }
 
         private Task CacheItAsync(ISchemaEntity schema, bool publish)
         {
             return Task.WhenAll(
-                replicatedCache.AddAsync(GetCacheKey(schema.AppId.Id, schema.Id), schema, CacheDuration, publish),
-                replicatedCache.AddAsync(GetCacheKey(schema.AppId.Id, schema.SchemaDef.Name), schema, CacheDuration, publish));
+                grainCache.AddAsync(GetCacheKey(schema.AppId.Id, schema.Id), schema, CacheDuration, publish),
+                grainCache.AddAsync(GetCacheKey(schema.AppId.Id, schema.SchemaDef.Name), schema, CacheDuration, publish));
         }
     }
 }
diff --git a/backend/src/Squidex.Infrastructure/UsageTracking/CachingUsageTracker.cs b/backend/src/Squidex.Infrastructure/UsageTracking/CachingUsageTracker.cs
index 9713175bd..dd01e9945 100644
--- a/backend/src/Squidex.Infrastructure/UsageTracking/CachingUsageTracker.cs
+++ b/backend/src/Squidex.Infrastructure/UsageTracking/CachingUsageTracker.cs
@@ -45,7 +45,7 @@ namespace Squidex.Infrastructure.UsageTracking
         {
             Guard.NotNull(key, nameof(key));
 
-            var cacheKey = string.Join("$", "Usage", nameof(GetForMonthAsync), key, date, category);
+            var cacheKey = $"{typeof(CachingUsageTracker)}_UsageForMonth_{key}_{date}_{category}";
 
             return cache.GetOrCreateAsync(cacheKey, entry =>
             {
@@ -59,7 +59,7 @@ namespace Squidex.Infrastructure.UsageTracking
         {
             Guard.NotNull(key, nameof(key));
 
-            var cacheKey = string.Join("$", "Usage", nameof(GetAsync), key, fromDate, toDate, category);
+            var cacheKey = $"{typeof(CachingUsageTracker)}_Usage_{key}_{fromDate}_{toDate}_{category}";
 
             return cache.GetOrCreateAsync(cacheKey, entry =>
             {