Implement caching for the most expensive queries.

Works by fetching the entire database into memory and then running queries directly against that data.

Author: siimav

RP1AnalyticsWebApp/Models/CachedCareerLogs.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.ComponentModel;
+
+namespace RP1AnalyticsWebApp.Models
+{
+    /// <summary>
+    /// Wrapper for cache entry.
+    /// Needs to be a 🦭ed class and have ImmutableObject attribute to prevent serialization and deserialization.
+    /// </summary>
+    [ImmutableObject(true)]
+    public sealed class CachedCareerLogs
+    {
+        public List<CareerLog> Items { get; set; }
+    }
+}

RP1AnalyticsWebApp/RP1AnalyticsWebApp.csproj

@@ -14,6 +14,7 @@
     <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.23.0" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation" Version="9.0.8" />
     <PackageReference Include="Microsoft.AspNetCore.OData" Version="8.3.1" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Hybrid" Version="9.10.0" />
     <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="9.0.0" />
     <PackageReference Include="MongoDB.Driver" Version="3.4.3" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="9.0.3" />

RP1AnalyticsWebApp/Services/CacheService.cs

@@ -0,0 +1,73 @@
+using Microsoft.ApplicationInsights;
+using Microsoft.Extensions.Caching.Hybrid;
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using RP1AnalyticsWebApp.Models;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace RP1AnalyticsWebApp.Services
+{
+    public class CacheService
+    {
+        private const string CacheKey = "AllCareerLogs";
+
+        private readonly HybridCache _cache;
+        private readonly TelemetryClient _telemetry;
+
+        public CacheService(HybridCache cache, TelemetryClient telemetry)
+        {
+            _cache = cache;
+            _telemetry = telemetry;
+        }
+
+        public async Task<List<CareerLog>> FetchAllCareersAsync(IMongoCollection<CareerLog> careerLogs)
+        {
+            CachedCareerLogs cacheEntry = await _cache.GetOrCreateAsync(
+                CacheKey,
+                FetchFromDB(careerLogs));
+
+            return cacheEntry.Items;
+        }
+
+        public async Task InvalidateAsync()
+        {
+            _telemetry.TrackEvent("InvalidateCache");
+            await _cache.RemoveAsync(CacheKey);
+        }
+
+        private Func<CancellationToken, ValueTask<CachedCareerLogs>> FetchFromDB(IMongoCollection<CareerLog> careerLogs)
+        {
+            return async cancel =>
+            {
+                var sw = Stopwatch.StartNew();
+                int totalCount = (int)await careerLogs.EstimatedDocumentCountAsync(cancellationToken: cancel);
+                int batchCount = Math.Clamp(totalCount / 50, 1, 10);
+                int defBatchSize = totalCount / batchCount;
+
+                var subLists = new List<CareerLog>[batchCount];
+                await Parallel.ForAsync(0, batchCount, async (int i, CancellationToken ct) =>
+                {
+                    var sw = Stopwatch.StartNew();
+                    int skip = i * defBatchSize;
+                    int curBatchSize = i == batchCount - 1 ? int.MaxValue : defBatchSize;
+                    List<CareerLog> itemBatch = await careerLogs.AsQueryable().Skip(skip).Take(curBatchSize).ToListAsync(ct);
+                    Console.WriteLine($"AllCareerLogs subbatch: {sw.ElapsedMilliseconds:N0} ms");
+                    subLists[i] = itemBatch;
+                });
+
+                List<CareerLog> allItems = subLists.SelectMany(l => l).ToList();
+                Console.WriteLine($"AllCareerLogs: {allItems.Count} items in {sw.ElapsedMilliseconds:N0} ms");
+                _telemetry.TrackEvent("FetchAllCareers", metrics: new Dictionary<string, double>
+                {
+                    { "QueryDuration", sw.ElapsedMilliseconds }
+                });
+                return new CachedCareerLogs { Items = allItems };
+            };
+        }
+    }
+}

RP1AnalyticsWebApp/Services/CareerLogService.cs

@@ -18,19 +18,21 @@ public class CareerLogService
         private readonly IProgramSettings _programSettings;
         private readonly ILeaderSettings _leaderSettings;
         private readonly UserManager<WebAppUser> _userManager;
+        private readonly CacheService _cache;
 
         private List<WebAppUser> _allUsers;
         private List<WebAppUser> AllUsers => _allUsers ??= _userManager.Users.ToList();
 
         public CareerLogService(ICareerLogDatabaseSettings dbSettings, IContractSettings contractSettings,
             ITechTreeSettings techTreeSettings, IProgramSettings programSettings, ILeaderSettings leaderSettings,
-            UserManager<WebAppUser> userManager)
+            UserManager<WebAppUser> userManager, CacheService cache)
         {
             _contractSettings = contractSettings;
             _techTreeSettings = techTreeSettings;
             _programSettings = programSettings;
             _leaderSettings = leaderSettings;
             _userManager = userManager;
+            _cache = cache;
 
             var client = new MongoClient(dbSettings.ConnectionString);
             var database = client.GetDatabase(dbSettings.DatabaseName);
@@ -39,17 +41,20 @@ public CareerLogService(ICareerLogDatabaseSettings dbSettings, IContractSettings
 
         public async Task<List<CareerLog>> GetAsync(ODataQueryOptions<CareerLog> queryOptions = null)
         {
-            var q = _careerLogs.AsQueryable();
+            List<CareerLog> all = await _cache.FetchAllCareersAsync(_careerLogs);
             if (queryOptions != null)
             {
+                var q = all.AsQueryable();
                 q = (IQueryable<CareerLog>)queryOptions.ApplyTo(q,
                     new ODataQuerySettings
                     {
                         HandleNullPropagation = HandleNullPropagationOption.False
                     },
                     AllowedQueryOptions.Supported ^ AllowedQueryOptions.Filter);
+                return q.ToList();
             }
-            return await q.ToListAsync();
+
+            return all;
         }
 
         public async Task<CareerLog> GetAsync(string id)
@@ -166,17 +171,10 @@ public async Task<List<ContractEventWithCount>> GetRepeatableContractCompletionC
 
         public async Task<List<ContractRecord>> GetContractRecordsAsync(ODataQueryOptions<CareerLog> queryOptions = null)
         {
-            var q = _careerLogs.AsQueryable();
-            if (queryOptions != null)
-            {
-                q = (IQueryable<CareerLog>)queryOptions.ApplyTo(q, new ODataQuerySettings
-                {
-                    HandleNullPropagation = HandleNullPropagationOption.False
-                });
-            }
+            var q = (await GetAsync(queryOptions)).AsQueryable();
 
-            var result = await q
-                .Where(c => c.EligibleForRecords)
+            var result = q
+                .Where(c => c.EligibleForRecords && c.ContractEventEntries != null)
                 .SelectMany(c => c.ContractEventEntries, (c, e) => new
                 {
                     CareerId = c.Id,
@@ -198,7 +196,7 @@ public async Task<List<ContractRecord>> GetContractRecordsAsync(ODataQueryOption
                     Date = g.Min(e => e.EventDate)
                 })
                 .OrderBy(c => c.Date)
-                .ToListAsync();
+                .ToList();
 
             result.ForEach(r =>
             {
@@ -211,17 +209,10 @@ public async Task<List<ContractRecord>> GetContractRecordsAsync(ODataQueryOption
 
         public async Task<List<ProgramRecord>> GetProgramRecordsAsync(ProgramRecordType type, ODataQueryOptions<CareerLog> queryOptions = null)
         {
-            var q = _careerLogs.AsQueryable();
-            if (queryOptions != null)
-            {
-                q = (IQueryable<CareerLog>)queryOptions.ApplyTo(q, new ODataQuerySettings
-                {
-                    HandleNullPropagation = HandleNullPropagationOption.False
-                });
-            }
+            var q = (await GetAsync(queryOptions)).AsQueryable();
 
             var allPrograms = q
-                .Where(c => c.EligibleForRecords)
+                .Where(c => c.EligibleForRecords && c.Programs != null)
                 .SelectMany(c => c.Programs, (c, p) => new ProgramRecord
                 {
                     CareerId = c.Id,
@@ -237,7 +228,7 @@ public async Task<List<ProgramRecord>> GetProgramRecordsAsync(ProgramRecordType
                 allPrograms = allPrograms.Where(p => p.Date.HasValue);
             }
 
-            var result = await allPrograms.OrderBy(p => p.Date)
+            var result = allPrograms.OrderBy(p => p.Date)
                 .GroupBy(p => p.ProgramName)
                 .Select(g => new ProgramRecord
                 {
@@ -248,7 +239,7 @@ public async Task<List<ProgramRecord>> GetProgramRecordsAsync(ProgramRecordType
                     Date = g.Min(p => p.Date)
                 })
                 .OrderBy(c => c.Date)
-                .ToListAsync();
+                .ToList();
 
             result.ForEach(r =>
             {
@@ -261,17 +252,10 @@ public async Task<List<ProgramRecord>> GetProgramRecordsAsync(ProgramRecordType
 
         public async Task<List<ProgramItemWithCareerInfo>> GetProgramRecordsAsync(ProgramRecordType type, string program, ODataQueryOptions<CareerLog> queryOptions = null)
         {
-            var q = _careerLogs.AsQueryable();
-            if (queryOptions != null)
-            {
-                q = (IQueryable<CareerLog>)queryOptions.ApplyTo(q, new ODataQuerySettings
-                {
-                    HandleNullPropagation = HandleNullPropagationOption.False
-                });
-            }
+            var q = (await GetAsync(queryOptions)).AsQueryable();
 
             var allPrograms = q
-                .Where(c => c.EligibleForRecords)
+                .Where(c => c.EligibleForRecords && c.Programs != null)
                 .SelectMany(c => c.Programs, (c, p) => new ProgramItemWithCareerInfo
                 {
                     CareerId = c.Id,
@@ -298,10 +282,10 @@ public async Task<List<ProgramItemWithCareerInfo>> GetProgramRecordsAsync(Progra
                 allPrograms = allPrograms.Where(p => p.Completed.HasValue);
             }
 
-            var result = await allPrograms
+            var result = allPrograms
                 .OrderBy(c => type == ProgramRecordType.Accepted ? c.Accepted :
                               type == ProgramRecordType.ObjectivesCompleted ? c.ObjectivesCompleted : c.Completed)
-                .ToListAsync();
+                .ToList();
 
             result.ForEach(r =>
             {
@@ -607,6 +591,7 @@ public async Task<CareerLog> CreateAsync(CareerLog log)
             careerLog.LaunchEventEntries = log.LaunchEventEntries;
 
             await _careerLogs.InsertOneAsync(careerLog);
+            await _cache.InvalidateAsync();
 
             return careerLog;
         }
@@ -645,7 +630,9 @@ public async Task<CareerLog> UpdateAsync(string token, CareerLogDto careerLogDto
                 .Set(nameof(CareerLog.Leaders), leaders);
             var opts = new FindOneAndUpdateOptions<CareerLog> { ReturnDocument = ReturnDocument.After };
 
-            return await _careerLogs.FindOneAndUpdateAsync(entry => entry.Token == token, updateDef, opts);
+            var res = await _careerLogs.FindOneAndUpdateAsync(entry => entry.Token == token, updateDef, opts);
+            await _cache.InvalidateAsync();
+            return res;
         }
 
         public async Task<CareerLog> GetByTokenAsync(string token)
@@ -656,6 +643,7 @@ public async Task<CareerLog> GetByTokenAsync(string token)
         public async Task DeleteByTokenAsync(string token)
         {
             await _careerLogs.DeleteOneAsync(entry => entry.Token == token);
+            await _cache.InvalidateAsync();
         }
 
         public async Task<CareerLog> UpdateMetaByTokenAsync(string token, string careerName, CareerLogMeta meta)
@@ -664,15 +652,19 @@ public async Task<CareerLog> UpdateMetaByTokenAsync(string token, string careerN
                                                              .Set(nameof(CareerLog.Name), careerName);
             var opts = new FindOneAndUpdateOptions<CareerLog> { ReturnDocument = ReturnDocument.After };
 
-            return await _careerLogs.FindOneAndUpdateAsync(entry => entry.Token == token, updateDefinition, opts);
+            var res = await _careerLogs.FindOneAndUpdateAsync(entry => entry.Token == token, updateDefinition, opts);
+            await _cache.InvalidateAsync();
+            return res;
         }
 
         public async Task<CareerLog> UpdateRaceAsync(string careerId, string race)
         {
             var updateDefinition = Builders<CareerLog>.Update.Set(nameof(CareerLog.Race), race);
             var opts = new FindOneAndUpdateOptions<CareerLog> { ReturnDocument = ReturnDocument.After };
 
-            return await _careerLogs.FindOneAndUpdateAsync(entry => entry.Id == careerId, updateDefinition, opts);
+            var res = await _careerLogs.FindOneAndUpdateAsync(entry => entry.Id == careerId, updateDefinition, opts);
+            await _cache.InvalidateAsync();
+            return res;
         }
 
         public async Task UpdateLaunchAsync(string careerId, LaunchEvent launch)
@@ -682,6 +674,7 @@ public async Task UpdateLaunchAsync(string careerId, LaunchEvent launch)
             var updateDef = Builders<CareerLog>.Update.Set(c => c.LaunchEventEntries.FirstMatchingElement(), launch);
 
             await _careerLogs.FindOneAndUpdateAsync(filterDef, updateDef);
+            await _cache.InvalidateAsync();
         }
 
         private string ResolveContractName(string name)

RP1AnalyticsWebApp/Startup.cs

@@ -6,6 +6,7 @@
 using Microsoft.AspNetCore.OData;
 using Microsoft.AspNetCore.OData.Formatter;
 using Microsoft.AspNetCore.OData.Formatter.MediaType;
+using Microsoft.Extensions.Caching.Hybrid;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -20,6 +21,7 @@
 using RP1AnalyticsWebApp.Models;
 using RP1AnalyticsWebApp.OData;
 using RP1AnalyticsWebApp.Services;
+using System;
 using System.Linq;
 using Vite.AspNetCore;
 
@@ -76,6 +78,7 @@ public void ConfigureServices(IServiceCollection services)
             BsonSerializer.RegisterSerializer(new GuidSerializer(GuidRepresentation.CSharpLegacy));
 
             services.AddTransient<CareerLogService>();
+            services.AddTransient<CacheService>();
 
             services.AddIdentityMongoDbProvider<WebAppUser, MongoRole>(identityOptions =>
             {
@@ -121,6 +124,16 @@ public void ConfigureServices(IServiceCollection services)
                 options.LoginPath = "/Identity/Account/Login";
             });
 
+            services.AddHybridCache(options =>
+            {
+                options.MaximumPayloadBytes = 512 * 1024 * 1024;    // 512 MB
+                options.DefaultEntryOptions = new HybridCacheEntryOptions
+                {
+                    Expiration = TimeSpan.FromHours(8),
+                    LocalCacheExpiration = TimeSpan.FromHours(8)
+                };
+            });
+
             services.AddHostedService<StartupHostedService>();
 
             services.AddViteServices(options =>