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);
}