public void Gauge(GaugeOptions options, Func <IMetricValueProvider <double> > valueProvider)
{
EnsureContextLabel(options);
var registry = _contexts.GetOrAdd(options.Context, _newContextRegistry);
registry.Gauge(options, valueProvider);
}
private static async Task RunGauge(IMetrics metrics, CancellationToken token)
{
const int delay = 1000;
var gauge = new GaugeOptions
{
Name = "MyGauge",
Context = nameof(RunGauge),
Tags = new MetricTags("delay", $"{delay}"),
MeasurementUnit = Unit.Bytes
};
var process = Process.GetCurrentProcess();
while (!token.IsCancellationRequested)
{
metrics.Measure.Gauge.SetValue(gauge, process.PrivateMemorySize64);
try
{
await Task.Delay(delay, token);
}
catch (TaskCanceledException)
{
await Task.CompletedTask;
}
}
}
public SystemUsageCollector(IMetrics metrics, string context = "System")
{
_metrics = metrics;
_lastTimeStamp = Process.GetCurrentProcess().StartTime;
_totalCpuUsed = new GaugeOptions
{
Context = context,
Name = "Total CPU Percentage Used",
MeasurementUnit = Unit.Percent
};
_privilegedCpuUsed = new GaugeOptions
{
Context = context,
Name = "Privileged CPU Percentage Used",
MeasurementUnit = Unit.Percent
};
_userCpuUsed = new GaugeOptions
{
Context = context,
Name = "User CPU Percentage Used",
MeasurementUnit = Unit.Percent
};
_memoryWorkingSet = new GaugeOptions
{
Context = context,
Name = "Memory Working Set",
MeasurementUnit = Unit.Bytes
};
_nonPagedSystemMemory = new GaugeOptions
{
Context = context,
Name = "Non Paged System Memory",
MeasurementUnit = Unit.Bytes
};
_pagedMemory = new GaugeOptions
{
Context = context,
Name = "Paged Memory",
MeasurementUnit = Unit.Bytes
};
_pagedSystemMemory = new GaugeOptions
{
Context = context,
Name = "Paged System Memory",
MeasurementUnit = Unit.Bytes
};
_privateMemory = new GaugeOptions
{
Context = context,
Name = "Private Memory",
MeasurementUnit = Unit.Bytes
};
_virtualMemory = new GaugeOptions
{
Context = context,
Name = "Virtual Memory",
MeasurementUnit = Unit.Bytes
};
}
internal static DefaultGauge Factory(string name, Action <GaugeOptions> init)
{
var options = new GaugeOptions();
init(options);
return(new DefaultGauge(name, options));
}
static void Main(string[] args)
{
var metrics = new MetricsBuilder()
.OutputMetrics.AsPlainText()
.OutputMetrics.AsJson()
.OutputMetrics.Using <CustomOutputFormatter>()
.Build();
var gaugeOptions = new GaugeOptions()
{
Name = "Test"
};
metrics.Measure.Gauge.SetValue(gaugeOptions, 10);
var snapshot = metrics.Snapshot.Get();
foreach (var formatter in metrics.OutputMetricsFormatters)
{
using (var stream = new MemoryStream())
{
formatter.WriteAsync(stream, snapshot).Wait();
var result = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(result);
}
}
Console.ReadKey();
}
public static void SetGauge(GaugeOptions options, long amount)
{
Preconditions.CheckNotNull(options);
Preconditions.CheckNotNull(amount);
MetricsCollector.ForEach(mroot => { mroot.Measure.Gauge.SetValue(options, amount); });
}
public static IMetrics RegisterOneMinuteRate(this IMetrics metrics, GaugeOptions ratio, MeterOptions hit, MeterOptions total, MetricTags tags)
{
if (ratio == null)
{
throw new ArgumentNullException(nameof(ratio));
}
if (hit == null)
{
throw new ArgumentNullException(nameof(hit));
}
if (total == null)
{
throw new ArgumentNullException(nameof(total));
}
Ratios.AddLast(
new Tuple <IMetrics, GaugeOptions, MeterOptions, MeterOptions, MetricTags>(metrics, ratio, hit, total,
tags));
if (!Timer.Enabled)
{
Timer.Start();
}
return(metrics);
}
public void Gauge(GaugeOptions gaugeOptions, Func <IMetricValueProvider <double> > valueProvider)
{
_gauges.GetOrAdd(gaugeOptions.Name, () =>
{
var gauge = valueProvider();
return(Tuple.Create(gauge, new GaugeValueSource(gaugeOptions.Name, gauge, gaugeOptions.MeasurementUnit, gaugeOptions.Tags)));
});
}
private static async Task Main(string[] args)
{
var metrics = AppMetrics.CreateDefaultBuilder().Build();
var counter = new CounterOptions {
Name = "my_counter"
};
metrics.Measure.Counter.Increment(counter);
var gauge = new GaugeOptions {
Name = "my_gauge"
};
metrics.Measure.Gauge.SetValue(gauge, 1);
var meter = new MeterOptions {
Name = "my_meter"
};
metrics.Measure.Meter.Mark(meter);
var histogram = new HistogramOptions {
Name = "my_histogram"
};
metrics.Measure.Histogram.Update(histogram, 10);
var timer = new TimerOptions {
Name = "my_timer"
};
using (metrics.Measure.Timer.Time(timer))
{
await Task.Delay(100);
}
var apdex = new ApdexOptions {
Name = "my_apdex", AllowWarmup = false, ApdexTSeconds = 0.1
};
using (metrics.Measure.Apdex.Track(apdex))
{
await Task.Delay(200);
}
var snapshot = metrics.Snapshot.Get();
using (var stream = new MemoryStream())
{
await metrics.DefaultOutputMetricsFormatter.WriteAsync(stream, snapshot);
var result = Encoding.UTF8.GetString(stream.ToArray());
WriteLine(result);
}
ReadKey();
}
public MetricsGauge(string name, IMeasureGaugeMetrics gaugeMetrics, List <string> labelNames)
: base(labelNames, new List <string>())
{
this.gaugeMetrics = gaugeMetrics;
this.gaugeOptions = new GaugeOptions
{
Name = name,
MeasurementUnit = Unit.Items
};
}
public void ReportValue(string name, int value, dynamic meta)
{
MetricTags tags = ExtractTags(meta);
var options = new GaugeOptions {
Name = name, Tags = tags, MeasurementUnit = Unit.Custom("ms")
};
mMetrics.Measure.Gauge.SetValue(options, value);
}
public void PendingLocalCommands(int value)
{
var options = new GaugeOptions
{
Name = "PendingCommands",
MeasurementUnit = Unit.Items
};
_settings.Metrics.Measure.Gauge.SetValue(options, value);
}
public MetricContextTestFixture()
{
ApdexOptions = new ApdexOptions
{
Name = "apdex"
};
CounterOptions = new CounterOptions
{
Name = "counter"
};
GaugeOptions = new GaugeOptions
{
Name = "gauge"
};
HistogramOptions = new HistogramOptions
{
Name = "histogram"
};
MeterOptions = new MeterOptions
{
Name = "meter"
};
TimerOptions = new TimerOptions
{
Name = "timer"
};
var tags = new GlobalMetricTags
{
{ "key1", "value1" },
{ "key2", "value2" }
};
var contextualTags = new ContextualMetricTagProviders
{
{ "key1", () => new Guid().ToString() },
{ "key2", () => new Guid().ToString() }
};
var samplingProvider = new DefaultSamplingReservoirProvider(() => new DefaultForwardDecayingReservoir());
Registry = new DefaultMetricContextRegistry("context_label", tags, contextualTags);
ApdexBuilder = new DefaultApdexBuilder(samplingProvider);
HistogramBuilder = new DefaultHistogramBuilder(samplingProvider);
CounterBuilder = new DefaultCounterBuilder();
GaugeBuilder = new DefaultGaugeBuilder();
MeterBuilder = new DefaultMeterBuilder();
TimerBuilder = new DefaultTimerBuilder(samplingProvider);
Clock = new StopwatchClock();
}
static MeasureGaugeBenchmark()
{
Metrics = new GaugeOptions[NumberOfMetrics];
for (var i = 0; i < NumberOfMetrics; i++)
{
Metrics[i] = new GaugeOptions {
Name = $"metric_{i:D4}"
};
}
}
public void SendGaugeData()
{
var processPhysicalMemoryGauge = new GaugeOptions
{
Name = option.name,
MeasurementUnit = Unit.MegaBytes
};
var process = Process.GetCurrentProcess();
root.Measure.Gauge.SetValue(processPhysicalMemoryGauge, process.WorkingSet64 / 1024.0 / 1024.0);
}
public static void CreateGauge(string name, Func <double> provider, Unit unit)
{
if (MetricsGlobalSettings.IsGaugesEnabled)
{
var options = new GaugeOptions()
{
Name = name,
MeasurementUnit = unit,
};
Metrics.Measure.Gauge.SetValue(options, provider);
}
}
public void can_set_value()
{
var metricName = "test_set_gauge";
var options = new GaugeOptions {
Name = metricName
};
_manager.SetValue(options, () => 2.0);
var data = _fixture.Registry.GetData(new NoOpMetricsFilter());
data.Contexts.Single().Gauges.Single(g => g.Name == metricName).Value.Should().Be(2.0);
}
public void Context_doesnt_exist_returns_default_gauge_when_multidimensional()
{
var metricName = "DefaultMetricValuesProviderTests_gauge_without_context_multi";
var options = new GaugeOptions
{
Name = "different",
Context = Context
};
_measure.Gauge.SetValue(options, _tags[1], () => 1.0);
_provider.GetGaugeValue(Context, _tags[1].AsMetricName(metricName)).Should().NotBe(1);
}
public void Can_get_gauge_value()
{
var metricName = "DefaultMetricValuesProviderTests_gauge";
var options = new GaugeOptions
{
Name = metricName,
Context = Context
};
_measure.Gauge.SetValue(options, () => 1.0);
_provider.GetGaugeValue(Context, metricName).Should().Be(1);
}
public void context_doesnt_exist_returns_default_gauge()
{
var metricName = "DefaultMetricValuesProviderTests_gauge_without_context";
var options = new GaugeOptions
{
Name = "different",
Context = Context
};
_measure.Gauge.SetValue(options, () => 1.0);
_provider.GetGaugeValue(Context, metricName).Should().NotBe(1);
}
public void Can_get_multidimensional_gauge_value()
{
var metricName = "DefaultMetricValuesProviderTests_gauge_multi";
var options = new GaugeOptions
{
Name = metricName,
Context = Context
};
_measure.Gauge.SetValue(options, _tags[0], () => 1.0);
_provider.GetGaugeValue(Context, _tags[0].AsMetricName(metricName)).Should().Be(1);
}
private void SetNodeItemsProcessed(Guid guid, string machineName, long itemsProcessed)
{
var tags = new MetricTags(new[] { "node_id", "machine_name" }, new[] { guid.ToString(), machineName });
var gauge = new GaugeOptions
{
Context = "node",
Tags = tags,
Name = "Node Items Processed",
MeasurementUnit = Unit.None
};
_metrics?.Measure.Gauge.SetValue(gauge, itemsProcessed);
}
public void Gauge(GaugeOptions options, Func <IMetricValueProvider <double> > valueProvider)
{
if (_nullMetricsRegistry.IsValueCreated)
{
_nullMetricsRegistry.Value.Gauge(options, valueProvider);
}
EnsureContextLabel(options);
var contextRegistry = _contexts.GetOrAdd(options.Context, _newContextRegistry);
contextRegistry.Gauge(options, valueProvider);
}
public async Task PublishAsync(HealthReport report, CancellationToken cancellationToken)
{
var gaugeOptions = new GaugeOptions
{
Context = "application.health",
MeasurementUnit = Unit.None
};
foreach (var entry in report.Entries)
{
gaugeOptions.Name = entry.Key;
_metrics.Measure.Gauge.SetValue(gaugeOptions, GetMetricValue(entry.Value.Status));
}
}
public void Can_get_gauge_value_with_tags()
{
var metricName = "DefaultMetricValuesProviderTests_gauge";
var options = new GaugeOptions
{
Name = metricName,
Context = Context
};
var tags = new MetricTags("key", "value");
_measure.Gauge.SetValue(options, tags, () => 1.0);
_provider.GetGaugeValue(Context, tags.AsMetricName(metricName)).Should().Be(1);
}
/// <inheritdoc />
public IGauge Gauge <T>(GaugeOptions options, MetricTags tags, Func <T> builder)
where T : IGaugeMetric
{
if (_nullMetricsRegistry.IsValueCreated)
{
return(_nullMetricsRegistry.Value.Gauge(options, tags, builder));
}
EnsureContextLabel(options);
var contextRegistry = _contexts.GetOrAdd(options.Context, _newContextRegistry);
return(contextRegistry.Gauge(options, tags, builder));
}
public void does_not_throw_on_metrics_of_different_type_with_same_name()
{
((Action)(() =>
{
var name = "Test";
var apdexOptions = new ApdexOptions
{
Name = name,
MeasurementUnit = Unit.Calls,
};
var counterOptions = new CounterOptions
{
Name = name,
MeasurementUnit = Unit.Calls,
};
var meterOptions = new MeterOptions
{
Name = name,
MeasurementUnit = Unit.Calls
};
var gaugeOptions = new GaugeOptions
{
Name = name,
MeasurementUnit = Unit.Calls
};
var histogramOptions = new HistogramOptions
{
Name = name,
MeasurementUnit = Unit.Calls
};
var timerOptions = new TimerOptions
{
Name = name,
MeasurementUnit = Unit.Calls
};
_fixture.Metrics.Measure.Apdex.Track(apdexOptions);
_fixture.Metrics.Measure.Gauge.SetValue(gaugeOptions, () => 0.0);
_fixture.Metrics.Measure.Counter.Increment(counterOptions);
_fixture.Metrics.Measure.Meter.Mark(meterOptions);
_fixture.Metrics.Measure.Histogram.Update(histogramOptions, 1L);
_fixture.Metrics.Measure.Timer.Time(timerOptions);
})).ShouldNotThrow();
}
static void Main(string[] args)
{
var metrics = new MetricsBuilder()
.Report.ToConsole()
.Build();
var cacheHitRatioGauge = new GaugeOptions
{
Name = "Cache Gauge",
MeasurementUnit = Unit.Calls
};
var cacheHitsMeter = new MeterOptions
{
Name = "Cache Hits Meter",
MeasurementUnit = Unit.Calls
};
var databaseQueryTimer = new TimerOptions
{
Name = "Database Query Timer",
MeasurementUnit = Unit.Calls,
DurationUnit = TimeUnit.Milliseconds,
RateUnit = TimeUnit.Milliseconds
};
var cacheHits = metrics.Provider.Meter.Instance(cacheHitsMeter);
var calls = metrics.Provider.Timer.Instance(databaseQueryTimer);
var cacheHit = new Random().Next(0, 2) == 0;
using (calls.NewContext())
{
if (cacheHit)
{
cacheHits.Mark(5);
}
Thread.Sleep(cacheHit ? 10 : 100);
}
var val = cacheHits.GetValueOrDefault();
metrics.Measure.Gauge.SetValue(cacheHitRatioGauge, () => new HitRatioGauge(cacheHits, calls, m => m.OneMinuteRate));
Task.WhenAll(metrics.ReportRunner.RunAllAsync());
Console.ReadKey();
}
public void Can_add_multidimensional_to_registry_with_default_builder()
{
var metricName = "gauge_provider_test_default_builder";
var options = new GaugeOptions
{
Name = metricName
};
_provider.Instance(options, _fixture.Tags[0]);
_filter.WhereName(name => name == metricName);
_fixture.Registry.GetData(_filter).Contexts.First().Gauges.Count().Should().Be(1);
}
public void Can_add_multidimensional_to_registry()
{
var metricName = "gauge_provider_test_multi";
var options = new GaugeOptions
{
Name = metricName
};
_provider.Instance(options, _fixture.Tags[0], () => new FunctionGauge(() => 1.0));
_filter.WhereName(name => name == _fixture.Tags[0].AsMetricName(metricName));
_fixture.Registry.GetData(_filter).Contexts.First().Gauges.Count().Should().Be(1);
}
