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