private static IDictionary <string, long> GetCacheBulkStatistics(ICacheCoreSession session) { var cacheStatistics = new Dictionary <string, long>(); foreach (var statistic in GetLoggedStatistics(session, out _)) { cacheStatistics.Add(statistic.qualifiedId, statistic.value); } return(cacheStatistics); }
private CacheCoreCacheInitializer( LoggingContext loggingContext, ICacheCoreCache cache, ICacheCoreSession session, List <IDisposable> acquiredDisposables, bool enableFingerprintLookup, RootTranslator rootTranslator) : base( loggingContext, acquiredDisposables, enableFingerprintLookup) { Contract.Requires(cache != null); Contract.Requires(session != null); m_cache = cache; m_session = session; m_rootTranslator = rootTranslator; m_initialStatistics = GetCacheBulkStatistics(session); }
private static IEnumerable <(string cacheId, string cacheType, string qualifiedId, string id, long value)> GetLoggedStatistics(ICacheCoreSession session, out Dictionary <string, string> cacheNameMap) { cacheNameMap = null; var statistics = new List <(string, string, string, string, long)>(); var maybeStats = session.GetStatisticsAsync().GetAwaiter().GetResult(); if (maybeStats.Succeeded) { var stats = maybeStats.Result; cacheNameMap = BuildCacheNameMap(stats); foreach (var singleCacheStats in stats) { foreach (KeyValuePair <string, double> statValue in singleCacheStats.Statistics) { // The *Sum2 stats are sum of squares of values and while stored as doubles can esaily explode a ulong, so they'll drop here. // If those stats are wanted, they should be collected via an ETW based telemtry system. if (!statValue.Key.EndsWith("Sum2", StringComparison.OrdinalIgnoreCase)) { var value = Convert.ToInt64(statValue.Value); statistics.Add(( singleCacheStats.CacheId, singleCacheStats.CacheType, $"{singleCacheStats.CacheId}.{statValue.Key}", statValue.Key, value)); } } } } return(statistics); }
internal static async Task <Possible <CacheCoreCacheInitializer> > TryInitializeCacheInternalAsync( LoggingContext loggingContext, PathTable pathTable, string cacheDirectory, ICacheConfiguration config, bool enableFingerprintLookup, RootTranslator rootTranslator) { Contract.Requires(pathTable != null); Contract.Requires(pathTable.IsValid); Contract.Requires(config != null); Contract.Requires(config.CacheLogFilePath.IsValid); Contract.Requires(config.CacheConfigFile.IsValid); Contract.Requires(!string.IsNullOrWhiteSpace(cacheDirectory)); bool succeeded = false; ICacheCoreCache cache = null; ICacheCoreSession session = null; try { Possible <ICacheConfigData> cacheConfigData = TryGetCacheConfigData(pathTable, cacheDirectory, config, rootTranslator); if (!cacheConfigData.Succeeded) { return(cacheConfigData.Failure); } Possible <ICacheCoreCache> maybeCache = await CacheFactory.InitializeCacheAsync(cacheConfigData.Result, loggingContext.ActivityId, config); if (!maybeCache.Succeeded) { return(maybeCache.Failure); } // We are now responsible for shutting this down (even if something later fails). cache = maybeCache.Result; cache.SuscribeForCacheStateDegredationFailures( failure => { Tracing.Logger.Log.CacheReportedRecoverableError(loggingContext, failure.DescribeIncludingInnerFailures()); }); // Log the cache ID we got. Tracing.Logger.Log.CacheInitialized(loggingContext, cache.CacheId); Possible <ICacheCoreSession> maybeSession = string.IsNullOrWhiteSpace(config.CacheSessionName) ? await cache.CreateSessionAsync() : await cache.CreateSessionAsync(config.CacheSessionName); if (!maybeSession.Succeeded) { return(maybeSession.Failure); } session = maybeSession.Result; succeeded = true; return(new CacheCoreCacheInitializer( loggingContext, cache, session, new List <IDisposable>(), enableFingerprintLookup: enableFingerprintLookup, rootTranslator: rootTranslator, replaceExistingFileOnMaterialization: config.ReplaceExistingFileOnMaterialization)); } finally { if (!succeeded) { // Note that we clean up in reverse order that we initialized things. if (session != null) { Analysis.IgnoreResult(await session.CloseAsync(), justification: "Okay to ignore close"); Analysis.IgnoreResult(await cache.ShutdownAsync(), justification: "Okay to ignore shutdown"); } } } }