public ActiveMqMetricsRecorder(string name, ActiveMqMetricsOptions options, IMetrics metrics)
{
Name = name;
_metrics = metrics;
_messageSendTime = new HistogramOptions
{
Context = options.Context,
Name = "Message Send Time",
MeasurementUnit = Unit.Custom("ns")
};
_messageSendRate = new MeterOptions
{
Context = options.Context,
Name = "Message Send Rate",
MeasurementUnit = Unit.Custom("msg")
};
_messageProcessingTime = new HistogramOptions
{
Context = options.Context,
Name = "Message Processing Time",
MeasurementUnit = Unit.Custom("ns")
};
_messageProcessingRate = new MeterOptions
{
Context = options.Context,
Name = "Message Processing Rate",
MeasurementUnit = Unit.Custom("msg"),
};
}
public void MarkErrorCount(MeterOptions meterOptions)
{
if (this.AllowedMetrics.HasFlag(CacheMetrics.ErrorCount))
{
this.MetricsObj.Measure.Meter.Mark(meterOptions, MetricsTags);
}
}
private static async Task RunMeter(IMetrics metrics, CancellationToken token)
{
var meter = new MeterOptions
{
Name = "MyMeter",
Context = nameof(RunMeter),
Tags = new MetricTags("delay", "random"),
MeasurementUnit = Unit.Calls,
ReportSetItems = true
};
var random = new Random();
var counter = 0;
while (!token.IsCancellationRequested)
{
var delay = random.Next(100, 200);
var route = counter % 2 == 0 ? "/user" : "/account";
counter++;
metrics.Measure.Meter.Mark(meter, route);
await DelayOrComplete(token, delay);
}
}
public AppMetricBehavior(IMetricsRoot metrics)
{
_metrics = metrics;
_requestMetric = new MeterOptions()
{
Name = "Mediator Requests",
MeasurementUnit = App.Metrics.Unit.Requests,
RateUnit = TimeUnit.Seconds,
Context = "application"
};
_exeTimer = new TimerOptions()
{
Name = "Mediator Requests Execution Time",
MeasurementUnit = App.Metrics.Unit.Requests,
DurationUnit = TimeUnit.Milliseconds,
RateUnit = TimeUnit.Seconds,
Context = "application"
};
_exception = new MeterOptions()
{
Name = "Mediator Requests Exceptions",
MeasurementUnit = App.Metrics.Unit.Requests,
RateUnit = TimeUnit.Seconds,
Context = "application"
};
}
/// <inheritdoc />
public void Mark(MeterOptions options, long amount, Action <MetricItem> itemSetup)
{
var item = new MetricItem();
itemSetup(item);
_registry.Meter(options, () => Advanced.BuildMeter(options)).Mark(item, amount);
}
public IMeter Meter <T>(MeterOptions options, Func <T> builder) where T : IMeterMetric
{
EnsureContextLabel(options);
var registry = _contexts.GetOrAdd(options.Context, _newContextRegistry);
return(registry.Meter(options, builder));
}
public IMeter Meter <T>(MeterOptions options, Func <T> builder) where T : IMeterMetric
{
return(_meters.GetOrAdd(options.Name, () =>
{
var meter = builder();
return Tuple.Create((IMeter)meter, new MeterValueSource(options.Name, meter, options.MeasurementUnit, options.RateUnit, options.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 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();
}
public void can_mark_with_metric_item_by_amount()
{
var metricName = "test_mark_meter_with_metric_item_by_amount";
var options = new MeterOptions {
Name = metricName
};
_manager.Mark(options, 5L, new MetricSetItem("tagKey", "tagvalue"));
_fixture.Snapshot.GetMeterValue(_context, metricName).Items.Length.Should().Be(1);
}
static MeasureMeterBenchmark()
{
Metrics = new MeterOptions[NumberOfMetrics];
for (var i = 0; i < NumberOfMetrics; i++)
{
Metrics[i] = new MeterOptions {
Name = $"metric_{i:D4}"
};
}
}
protected IMeter CreateMeter(string contextName, string name, bool suppressExportMetrics, MetricTags tags)
{
var meterOptions = new MeterOptions
{
Context = contextName,
Name = name,
ReportSetItems = !suppressExportMetrics
};
return(new Meter(_metrics.Provider.Meter, _metrics.Measure.Meter, meterOptions, tags));
}
public void can_mark_with_item()
{
var metricName = "test_mark_meter_with_item";
var options = new MeterOptions {
Name = metricName
};
_manager.Mark(options, "item1");
_fixture.Snapshot.GetMeterValue(_context, metricName).Items.Length.Should().Be(1);
}
public void Can_get_multidimensional_meter_value()
{
var metricName = "DefaultMetricValuesProviderTests_meter_multi";
var options = new MeterOptions
{
Name = metricName,
Context = Context
};
_measure.Meter.Mark(options, _tags[1], 1L);
_provider.GetMeterValue(Context, _tags[1].AsMetricName(metricName)).Count.Should().Be(1);
}
public void Can_get_meter_value()
{
var metricName = "DefaultMetricValuesProviderTests_meter";
var options = new MeterOptions
{
Name = metricName,
Context = Context
};
_measure.Meter.Mark(options, 1L);
_provider.GetMeterValue(Context, metricName).Count.Should().Be(1);
}
public void can_mark_multidimensional_with_item()
{
var metricName = "test_mark_meter_with_item_multi";
var options = new MeterOptions {
Name = metricName
};
_manager.Mark(options, _fixture.Tags[0], "item1");
_manager.Mark(options, _fixture.Tags[1], "item1");
_fixture.Snapshot.GetMeterValue(_context, _fixture.Tags[0].AsMetricName(metricName)).Items.Length.Should().Be(1);
_fixture.Snapshot.GetMeterValue(_context, _fixture.Tags[1].AsMetricName(metricName)).Items.Length.Should().Be(1);
}
public void can_mark_by_amount()
{
var metricName = "test_mark_meter_by_amount";
var options = new MeterOptions {
Name = metricName
};
_manager.Mark(options, 2L);
var data = _fixture.Registry.GetData(new NoOpMetricsFilter());
data.Contexts.Single().Meters.Count(x => x.Name == metricName).Should().Be(1);
}
public void context_doesnt_exist_returns_default_meter()
{
var metricName = "DefaultMetricValuesProviderTests_meter_without_context";
var options = new MeterOptions
{
Name = "different",
Context = Context
};
_measure.Meter.Mark(options, 1L);
_provider.GetMeterValue(Context, metricName).Should().Be(default(MeterValue));
}
public void Context_doesnt_exist_returns_default_meter_when_multidimensional()
{
var metricName = "DefaultMetricValuesProviderTests_meter_without_context_multi";
var options = new MeterOptions
{
Name = "different",
Context = Context
};
_measure.Meter.Mark(options, _tags[0], 1L);
_provider.GetMeterValue(Context, _tags[0].AsMetricName(metricName)).Should().Be(default(MeterValue));
}
public void Can_get_meter_value_with_tags()
{
var metricName = "DefaultMetricValuesProviderTests_meter";
var options = new MeterOptions
{
Name = metricName,
Context = Context
};
var tags = new MetricTags("key", "value");
_measure.Meter.Mark(options, tags, 1L);
_provider.GetMeterValue(Context, tags.AsMetricName(metricName)).Count.Should().Be(1);
}
public void Can_add_instance_to_registry()
{
var metricName = "meter_provider_test";
var options = new MeterOptions
{
Name = metricName
};
_provide.Instance(options);
_filter.WhereName(name => name == metricName);
_fixture.Registry.GetData(_filter).Contexts.First().Meters.Count().Should().Be(1);
}
public void Can_add_multidimensional_to_registry()
{
var metricName = "meter_provider_test_multi";
var options = new MeterOptions
{
Name = metricName
};
_provide.Instance(options, _fixture.Tags[0]);
_filter.WhereName(name => name == _fixture.Tags[0].AsMetricName(metricName));
_fixture.Registry.GetData(_filter).Contexts.First().Meters.Count().Should().Be(1);
}
public IMeter Meter <T>(MeterOptions options, MetricTags tags, Func <T> builder)
where T : IMeterMetric
{
if (_nullMetricsRegistry.IsValueCreated)
{
return(_nullMetricsRegistry.Value.Meter(options, tags, builder));
}
EnsureContextLabel(options);
var contextRegistry = _contexts.GetOrAdd(options.Context, _newContextRegistry);
return(contextRegistry.Meter(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_mark_multidimensional()
{
var metricName = "test_mark_meter_multi";
var options = new MeterOptions {
Name = metricName
};
_manager.Mark(options, _fixture.Tags[0]);
_manager.Mark(options, _fixture.Tags[1]);
var data = _fixture.Registry.GetData(new NoOpMetricsFilter());
data.Contexts.Single().Meters.Count(x => x.Name == _fixture.Tags[0].AsMetricName(metricName)).Should().Be(1);
data.Contexts.Single().Meters.Count(x => x.Name == _fixture.Tags[1].AsMetricName(metricName)).Should().Be(1);
}
public void can_mark_when_multidimensional_with_metric_item_by_amount()
{
var metricName = "test_mark_meter_with_metric_item_by_amount_multi";
var options = new MeterOptions {
Name = metricName
};
_manager.Mark(options, _fixture.Tags[0], 5L, new MetricSetItem("tagKey", "tagvalue"));
_manager.Mark(options, _fixture.Tags[1], 20L, new MetricSetItem("tagKey", "tagvalue"));
_fixture.Snapshot.GetMeterValue(_context, _fixture.Tags[0].AsMetricName(metricName)).Items.Length.Should().Be(1);
_fixture.Snapshot.GetMeterValue(_context, _fixture.Tags[0].AsMetricName(metricName)).Count.Should().Be(5);
_fixture.Snapshot.GetMeterValue(_context, _fixture.Tags[1].AsMetricName(metricName)).Items.Length.Should().Be(1);
_fixture.Snapshot.GetMeterValue(_context, _fixture.Tags[1].AsMetricName(metricName)).Count.Should().Be(20);
}
private static MeterOptions GetOrAddMeter(string type, IDictionary <string, MeterOptions> meters)
{
if (meters.ContainsKey(type))
{
return(meters[type]);
}
var meter = new MeterOptions
{
Name = $"{type}_messages",
MeasurementUnit = Unit.Events
};
meters[type] = meter;
return(meter);
}
public void can_add_add_new_instance_to_registry()
{
var metricName = "meter_provider_metric_test";
var options = new MeterOptions
{
Name = metricName
};
var meterMetric = _fixture.Builder.Meter.Build(_fixture.Clock);
_provide.Instance(options, () => meterMetric);
_filter.WhereMetricName(name => name == metricName);
_fixture.Registry.GetData(_filter).Contexts.First().Meters.Count().Should().Be(1);
}
public void can_mark_multidimensional_with_item_by_amount()
{
var metricName = "test_mark_meter_with_item_by_amount_multi";
var options = new MeterOptions {
Name = metricName
};
_manager.Mark(options, _fixture.Tags[0], 5L, "item1");
_manager.Mark(options, _fixture.Tags[1], 500L, "item1");
var data = _fixture.Registry.GetData(new NoOpMetricsFilter());
_fixture.Snapshot.GetMeterValue(_context, _fixture.Tags[0].AsMetricName(metricName)).Items.Length.Should().Be(1);
data.Contexts.Single().Meters.First(x => x.Name == _fixture.Tags[0].AsMetricName(metricName)).Value.Count.Should().Be(5);
_fixture.Snapshot.GetMeterValue(_context, _fixture.Tags[1].AsMetricName(metricName)).Items.Length.Should().Be(1);
data.Contexts.Single().Meters.First(x => x.Name == _fixture.Tags[1].AsMetricName(metricName)).Value.Count.Should().Be(500);
}
