private async Task <GetStatsResult> GetStatsInternalAsync(Context context) { try { var aggregateStats = new CounterSet(); var cachestats = _tracer.GetCounters(); aggregateStats.Merge(cachestats); if (_writeThroughContentStore != null) { var writeThroughStoreStats = await _writeThroughContentStore.GetStatsAsync(context); if (writeThroughStoreStats.Succeeded) { aggregateStats.Merge(writeThroughStoreStats.CounterSet, "WriteThroughStore."); } } if (_backingContentStore != null) { var backingContentStoreStats = _backingContentStore.GetStats(); if (backingContentStoreStats.Succeeded) { aggregateStats.Merge(backingContentStoreStats.CounterSet, "BackingContentStore."); } } return(new GetStatsResult(aggregateStats)); } catch (Exception ex) { return(new GetStatsResult(ex)); } }
/// <inheritdoc /> public async Task <GetStatsResult> GetStatsAsync(Context context) { try { GetStatsResult stats = await _innerICache.GetStatsAsync(context); GetStatsResult currentStats = GetStatsInternal(); CounterSet counterSet = new CounterSet(); if (stats.Succeeded) { counterSet.Merge(stats.CounterSet, $"{_innerICache.GetType().Name}."); } if (currentStats.Succeeded) { counterSet.Merge(currentStats.CounterSet, $"{nameof(DistributedCache)}."); } return(new GetStatsResult(counterSet)); } catch (Exception ex) { return(new GetStatsResult(ex)); } }
public CounterSet GetCounters(OperationContext context, Role?role, Counter counter) { var counters = new CounterSet(); counters.Merge(Counters.ToCounterSet(), "RaidedRedis."); counters.Merge(PrimaryRedisDb.Counters.ToCounterSet(), "Redis."); if (role != Role.Worker) { // Don't print redis counters on workers counters.Merge(PrimaryRedisDb.GetRedisCounters(context, Tracer, counter), "RedisInfo."); } if (SecondaryRedisDb != null) { counters.Merge(SecondaryRedisDb.Counters.ToCounterSet(), "SecondaryRedis."); if (role != Role.Worker) { // Don't print redis counters on workers counters.Merge(SecondaryRedisDb.GetRedisCounters(context, Tracer, counter), "SecondaryRedisInfo."); } } return(counters); }
private async Task <GetStatsResult> GetStatsCoreAsync(Context context) { // Both ContentStore and MemoizationStore may be null if startup failed. // Using a helper function to avoid NRE. var statsResult = await GetStatsResultCoreAsync(ContentStore, store => store.GetStatsAsync(context)).ConfigureAwait(false); if (!statsResult || UseOnlyContentStats) { return(statsResult); } var counters = new CounterSet(); counters.Merge(statsResult.CounterSet); statsResult = await GetStatsResultCoreAsync(MemoizationStore, store => store.GetStatsAsync(context)).ConfigureAwait(false); if (!statsResult) { return(statsResult); } counters.Merge(statsResult.CounterSet); return(new GetStatsResult(counters)); }
/// <inheritdoc /> public virtual Task <GetStatsResult> GetStatsAsync(Context context) { return(GetStatsCall <ContentStoreTracer> .RunAsync( Tracer, new OperationContext(context), () => { return Task.WhenAll(ContentStore1.GetStatsAsync(context), ContentStore2.GetStatsAsync(context)) .ContinueWith( antecedent => { if (antecedent.IsFaulted) { return new GetStatsResult(antecedent.Exception); } if (antecedent.IsCanceled) { return new GetStatsResult($"{nameof(GetStatsAsync)} is cancelled"); } Contract.Assert(antecedent.Result.Length == 2); var counterSet = new CounterSet(); counterSet.Merge(antecedent.Result[0].CounterSet, NameOfContentStore1 + "."); counterSet.Merge(antecedent.Result[1].CounterSet, NameOfContentStore2 + "."); return new GetStatsResult(counterSet); }); })); }
/// <inheritdoc /> protected override CounterSet GetCounters() { var counters = new CounterSet(); counters.Merge(base.GetCounters()); counters.Merge(_memoizationCounters.ToCounterSet()); return(counters); }
/// <inheritdoc /> public Task <GetStatsResult> GetStatsAsync(Context context) { return(GetStatsCall <MemoizationStoreTracer> .RunAsync(Tracer, new OperationContext(context), () => { var counters = new CounterSet(); counters.Merge(Tracer.GetCounters(), $"{Component}."); counters.Merge(Tracer.GetSQLiteDatabaseCounters(), $"{Component}."); counters.Add($"{CurrentContentHashListCountName}", _currentRowCount); return Task.FromResult(new GetStatsResult(counters)); })); }
/// <nodoc /> public CounterSet GetPerformanceStats() { var set = new CounterSet(); var perfInfo = _perfStatsAggregator.ComputeMachinePerfInfo(ensureSample: true); set.AddMetric("MachineAvailableRamMb", perfInfo.AvailableRamMb ?? -1); set.AddMetric("CommitLimitMb", perfInfo.CommitLimitMb ?? -1); set.AddMetric("CommitTotalMb", perfInfo.CommitUsedMb ?? -1); set.AddMetric("CommitUsagePercentage", perfInfo.CommitUsagePercentage ?? -1); set.AddMetric("CpuUsagePercentage", perfInfo.CpuUsagePercentage); set.AddMetric("MachineBandwidth", perfInfo.MachineBandwidth); set.AddMetric("MachineKbitsPerSecReceived", (long)perfInfo.MachineKbitsPerSecReceived); set.AddMetric("MachineKbitsPerSecSent", (long)perfInfo.MachineKbitsPerSecSent); set.AddMetric("ProcessCpuPercentage", perfInfo.ProcessCpuPercentage); set.AddMetric("ProcessWorkingSetMB", perfInfo.ProcessWorkingSetMB); set.AddMetric("RamUsagePercentage", perfInfo.RamUsagePercentage ?? -1); set.AddMetric("TotalRamMb", perfInfo.TotalRamMb ?? -1); set.AddMetric("ProcessThreadCount", (long)_perfStatsAggregator.ProcessThreadCount.Latest); foreach (var diskStat in _perfStatsAggregator.DiskStats) { var diskSet = new CounterSet(); diskSet.Add("IdleTime", (long)diskStat.IdleTime.Latest); diskSet.Add("QueueDepth", (long)diskStat.QueueDepth.Latest); diskSet.Add("ReadTime", (long)diskStat.ReadTime.Latest); diskSet.Add("WriteTime", (long)diskStat.WriteTime.Latest); set.Merge(diskSet, $"{diskStat.Drive}."); } return(set); }
/// <nodoc /> public static CounterSet ToCounterSet(this CounterTracker counterTracker) { var result = new CounterSet(); foreach (var counterCollection in counterTracker.CounterCollections) { result.Merge(counterCollection.ToCounterSet()); } foreach ((var name, var tracker) in counterTracker.ChildCounterTrackers) { result.Merge(tracker.ToCounterSet(), name); } return(result); }
/// <inheritdoc /> public CounterSet GetCounters(Context context) { var counters = new CounterSet(); if (_configuration.HasReadOrWriteMode(ContentLocationMode.Redis)) { counters.Merge(_redisContentLocationStore.GetCounters(context)); } if (_configuration.HasReadOrWriteMode(ContentLocationMode.LocalLocationStore)) { counters.Merge(_localLocationStore.GetCounters(context), "LLS."); } return(counters); }
public Task <GetStatsResult> GetStatsAsync(Context context) { var operationContext = new OperationContext(context); return(operationContext.PerformOperationAsync( Tracer, async() => { CounterSet aggregatedCounters = new CounterSet(); var localStats = await _localContentStore.GetStatsAsync(context).ThrowIfFailure(); var backingStats = await _backingContentStore.GetStatsAsync(context).ThrowIfFailure(); aggregatedCounters.Merge(localStats.Value, "Local"); aggregatedCounters.Merge(backingStats.Value, "Backing"); return new GetStatsResult(aggregatedCounters); })); }
/// <inheritdoc /> public Task <GetStatsResult> GetStatsAsync(Context context) { return(GetStatsCall <MemoizationStoreTracer> .RunAsync(_tracer, new OperationContext(context), () => { var counters = new CounterSet(); counters.Merge(_tracer.GetCounters(), $"{_tracer.Name}."); return Task.FromResult(new GetStatsResult(counters)); })); }
/// <inheritdoc /> public async Task <Result <CounterSet> > GetStatsAsync(OperationContext context) { var counterSet = new CounterSet(); counterSet.Merge(_performanceCollector.GetPerformanceStats(), "MachinePerf."); foreach (var(name, store) in StoresByName) { var stats = await GetStatsAsync(store, context); if (!stats) { return(Result.FromError <CounterSet>(stats)); } counterSet.Merge(stats.CounterSet, $"{name}."); } return(counterSet); }
/// <inheritdoc /> protected override async Task <BoolResult> ShutdownCoreAsync(OperationContext operationContext) { var result = await RetryPolicy.ExecuteAsync(() => RpcClient.ShutdownAsync(operationContext)); var counterSet = new CounterSet(); counterSet.Merge(GetCounters(), $"{Tracer.Name}."); Tracer.TraceStatisticsAtShutdown(operationContext, counterSet, prefix: "ServiceClientContentSessionStats"); return(result); }
/// <inheritdoc /> protected override async Task <BoolResult> ShutdownCoreAsync(OperationContext operationContext) { var result = await RetryPolicy.ExecuteAsync(() => RpcClient.ShutdownAsync(operationContext)); var counterSet = new CounterSet(); counterSet.Merge(GetCounters(), $"{Tracer.Name}."); counterSet.LogOrderedNameValuePairs(s => Tracer.Debug(operationContext, s)); return(result); }
public virtual CounterSet GetCounters() { var counterSet = new CounterSet(); var callsCounterSet = new CounterSet(); foreach (var callCounter in CallCounters) { callCounter.AppendTo(callsCounterSet); } return(callsCounterSet.Merge(counterSet)); }
/// <inheritdoc /> public Task <GetStatsResult> GetStatsAsync(Context context) { return(GetStatsCall <ContentStoreTracer> .RunAsync( Tracer, new OperationContext(context), async() => { CounterSet aggregatedCounters = new CounterSet(); aggregatedCounters.Merge(SessionTracer.GetCounters(), $"{nameof(MultiplexedContentStore)}."); foreach (var kvp in _drivesWithContentStore) { var stats = await kvp.Value.GetStatsAsync(context); if (stats.Succeeded) { aggregatedCounters.Merge(stats.CounterSet, $"{kvp.Value.GetType().Name}.{kvp.Key}."); } } return new GetStatsResult(aggregatedCounters); })); }
/// <inheritdoc /> public Task <GetStatsResult> GetStatsAsync(Context context) { return(GetStatsCall <ContentStoreTracer> .RunAsync( ExecutionTracer, OperationContext(context), async() => { CounterSet aggregatedCounters = new CounterSet(); aggregatedCounters.Merge(SessionTracer.GetCounters(), $"{nameof(ServiceClientContentSession)}."); // Getting the stats from the remote as well. if (_grpcClient != null) { var getStats = await _grpcClient.GetStatsAsync(context); if (getStats.Succeeded) { aggregatedCounters.Merge(getStats.CounterSet, "ContentServer."); } } return new GetStatsResult(aggregatedCounters); })); }
private async Task <GetStatsResult> StatsAsync(Context context) { var counters = new CounterSet(); var statsResult = await ContentStore.GetStatsAsync(context).ConfigureAwait(false); if (!statsResult.Succeeded) { return(statsResult); } counters.Merge(statsResult.CounterSet); statsResult = await MemoizationStore.GetStatsAsync(context).ConfigureAwait(false); if (!statsResult.Succeeded) { return(statsResult); } counters.Merge(statsResult.CounterSet); return(new GetStatsResult(counters)); }
public override CounterSet GetCounters() { var counterSet = new CounterSet(); foreach (var counter in _counters) { counterSet.Add(counter.Name, counter.Value); } var callsCounterSet = new CounterSet(); foreach (var callCounter in CallCounters) { callCounter.AppendTo(callsCounterSet); } return(callsCounterSet.Merge(counterSet)); }
/// <inheritdoc /> async Task <Result <CounterSet> > ISessionHandler <TSession> .GetStatsAsync(OperationContext context) { var counterSet = new CounterSet(); foreach (var store in StoresByName.Values) { var stats = await GetStatsAsync(store, context); if (!stats) { return(Result.FromError <CounterSet>(stats)); } counterSet.Merge(stats.CounterSet); } return(counterSet); }
/// <summary> /// Gets the counters collected by this tracer instance. /// </summary> public CounterSet GetCounters() { var aggregatedCounters = new CounterSet(); aggregatedCounters.Merge(ContentSessionTracer.GetCounters()); var countersStored = aggregatedCounters.ToDictionaryIntegral(); foreach (var counter in MemoizationStoreTracer.GetCounters().ToDictionaryIntegral()) { if (!countersStored.ContainsKey(counter.Key)) { aggregatedCounters.Add(counter.Key, counter.Value); } } foreach (Counter counter in _counters) { aggregatedCounters.Add(counter.Name, counter.Value); } return(aggregatedCounters); }