/// <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);
}
/// <summary>
/// Append counter data to caller's set.
/// </summary>
public void AppendTo(CounterSet counterSet)
{
var totalMilliseconds = Duration.TotalMilliseconds;
counterSet.Add(_count.Name, _count.Value);
counterSet.Add($"{_callName}AverageMs", _count.Value != 0 ? (long)(totalMilliseconds / _count.Value) : 0);
counterSet.Add($"{_callName}CallMs", (long)totalMilliseconds);
}
public void ThrowsWhenDuplicateMetricNamesAreAdded()
{
var counterSet = new CounterSet();
Assert.Throws <ArgumentException>(AddDuplicateMetricNames);
void AddDuplicateMetricNames()
{
counterSet.Add("someName", 0, "theMetricName");
counterSet.Add("otherName", 9, "theMetricName");
}
}
public void ThrowsWhenDuplicateNamesAreAdded()
{
var counterSet = new CounterSet();
Assert.Throws <ArgumentException>(AddDuplicateNames);
void AddDuplicateNames()
{
counterSet.Add("theName", 0);
counterSet.Add("theName", 9);
}
}
/// <inheritdoc />
public CounterSet GetCounters()
{
var counters = new CounterSet();
if (_calls > 0)
{
counters.Add("ContentHasherCalls", Interlocked.Read(ref _calls));
counters.Add("ContentHasherMs", (long)new TimeSpan(Interlocked.Read(ref _ticks)).TotalMilliseconds);
counters.Add("ContentHasherMaxConcurrency", _algorithmsPool.Size);
}
return(counters);
}
/// <inheritdoc />
public CounterSet GetSQLiteDatabaseCounters()
{
var counters = new CounterSet();
counters.Add("SQLiteDatabaseSize", _sqliteDatabaseSize);
return(counters);
}
public static CounterSet GetRedisCounters(this RedisDatabaseAdapter adapter, OperationContext context, Tracer tracer, Counter counter)
{
var redisInfo = adapter.GetRedisInfoAsync(context, tracer, counter, serverId: null, trace: false).GetAwaiter().GetResult();
var counterSet = new CounterSet();
if (!redisInfo)
{
// The error is already logged.
return(counterSet);
}
foreach ((var serverId, var info) in redisInfo.Value.Info)
{
AddCounterValue($"{serverId}.{nameof(info.Uptime)}", (long?)info.Uptime?.TotalSeconds);
AddCounterValue($"{serverId}.{nameof(info.KeyCount)}", info.KeyCount);
AddCounterValue($"{serverId}.{nameof(info.ExpirableKeyCount)}", info.ExpirableKeyCount);
AddCounterValue($"{serverId}.{nameof(info.EvictedKeys)}", info.EvictedKeys);
AddCounterValue($"{serverId}.{nameof(info.KeySpaceHits)}", info.KeySpaceHits);
AddCounterValue($"{serverId}.{nameof(info.KeySpaceMisses)}", info.KeySpaceMisses);
AddCounterValue($"{serverId}.{nameof(info.UsedCpuAveragePersentage)}", info.UsedCpuAveragePersentage);
AddCounterValue($"{serverId}.{nameof(info.UsedMemory)}Mb", (long?)(info.UsedMemory / Math.Pow(2, 20)));
AddCounterValue($"{serverId}.{nameof(info.UsedMemoryRss)}Mb", (long?)(info.UsedMemoryRss / Math.Pow(2, 20)));
}
return(counterSet);
void AddCounterValue(string name, long?value)
{
if (value != null)
{
counterSet.Add(name, value.Value);
}
}
}
/// <nodoc />
public static CounterSet ToCounterSet(this CounterCollection counters)
{
var counterSet = new CounterSet();
foreach ((var counter, var counterName) in counters.GetCounters())
{
counterSet.Add($"{counterName}.Count", (long)counter.Value, counter.Name);
if (counter.IsStopwatch)
{
counterSet.Add($"{counterName}.AverageMs", counter.Value != 0 ? (long)counter.Duration.TotalMilliseconds / counter.Value : 0);
counterSet.Add($"{counterName}.DurationMs", (long)counter.Duration.TotalMilliseconds);
}
}
return(counterSet);
}
/// <summary>
/// Run the call.
/// </summary>
public static async Task <GetStatsResult> RunAsync(TTracer tracer, OperationContext context, Func <Task <GetStatsResult> > funcAsync)
{
using (var call = new GetStatsCall <TTracer>(tracer, context))
{
var result = await call.RunAsync(funcAsync);
if (result)
{
var stats = new CounterSet();
stats.Add("CriticalErrors", tracer.NumberOfCriticalErrors);
stats.Add("RecoverableErrors", tracer.NumberOfRecoverableErrors);
result.CounterSet.Merge(stats, $"{tracer.GetType().Name}.{tracer.Name}.ErrorStats.");
}
return(result);
}
}
/// <summary>
/// Get pin cache counters
/// </summary>
public CounterSet GetCounters(Context context)
{
var counterSet = new CounterSet();
foreach (var counter in Counters)
{
counterSet.Add(counter.Name, counter.Value);
}
return(counterSet);
}
/// <nodoc />
public static CounterSet ToCounterSet <TEnum>(this CounterCollection <TEnum> counters)
where TEnum : struct
{
CounterSet counterSet = new CounterSet();
foreach (var counterEnum in EnumTraits <TEnum> .EnumerateValues())
{
var counter = counters[counterEnum];
var counterName = counterEnum.ToString();
counterSet.Add($"{counterName}.Count", (long)counter.Value, counter.Name);
if (counter.IsStopwatch)
{
counterSet.Add($"{counterName}.AverageMs", counter.Value != 0 ? (long)counter.Duration.TotalMilliseconds / counter.Value : 0);
counterSet.Add($"{counterName}.DurationMs", (long)counter.Duration.TotalMilliseconds);
}
}
return(counterSet);
}
/// <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));
}));
}
/// <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);
}
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));
}
/// <summary>
/// Gets the statistics from the remote.
/// </summary>
public async Task <GetStatsResult> GetStatsAsync(Context context)
{
CounterSet counters = new CounterSet();
// Get stats iff compatible with service and client
if ((_serviceCapabilities & Capabilities.GetStats) != 0 &&
(_clientCapabilities & Capabilities.GetStats) != 0)
{
var response = await SendGrpcRequestAsync(context, async() => await GetStatsAsync(new GetStatsRequest()));
if (response.Success)
{
foreach (var entry in response.Statistics)
{
counters.Add(entry.Key, entry.Value);
}
}
}
return(new GetStatsResult(counters));
}
