public void ThrowOnNameConflict_Tuple()
{
var registry = new CollectorRegistry();
var factory = new MetricFactory(registry);
factory.CreateGaugeInt64("test_gauge", string.Empty, ("label1", "label2"));
Assert.Throws <InvalidOperationException>(() => factory.CreateGaugeInt64("test_gauge", string.Empty, ValueTuple.Create()));
Assert.Throws <InvalidOperationException>(() => factory.CreateGaugeInt64("test_gauge", string.Empty, ValueTuple.Create("label1")));
Assert.Throws <InvalidOperationException>(() => factory.CreateGaugeInt64("test_gauge", string.Empty, ("label1", "testlabel")));
Assert.Throws <InvalidOperationException>(() => factory.CreateGaugeInt64("test_gauge", string.Empty, ("label1", "label2", "label3")));
}
public void ThrowOnNameConflict_Strings()
{
var registry = new CollectorRegistry();
var factory = new MetricFactory(registry);
factory.CreateGaugeInt64("test_gauge", string.Empty, "label1", "label2");
Assert.Throws <InvalidOperationException>(() => factory.CreateGaugeInt64("test_gauge", string.Empty, Array.Empty <string>()));
Assert.Throws <InvalidOperationException>(() => factory.CreateGaugeInt64("test_gauge", string.Empty, "label1", "testlabel"));
Assert.Throws <InvalidOperationException>(() => factory.CreateGaugeInt64("test_gauge", string.Empty, new[] { "label1" }));
Assert.Throws <InvalidOperationException>(() => factory.CreateGaugeInt64("test_gauge", string.Empty, "label1", "label2", "label3"));
}
public void Setup()
{
_registry = Metrics.NewCustomRegistry();
_factory = Metrics.WithCustomRegistry(_registry);
_inProgressMiddleware =
new HttpInProgressMiddleware(next => Task.CompletedTask, _factory.CreateGauge("in_progress", "help"));
_countMiddleware =
new HttpRequestCountMiddleware(next => Task.CompletedTask, _factory.CreateCounter("count", "help"));
_durationMiddleware =
new HttpRequestDurationMiddleware(next => Task.CompletedTask, _factory.CreateHistogram("duration", "help"));
}
public void CannotDecrement()
{
var registry = new CollectorRegistry();
var factory = new MetricFactory(registry);
var counter = factory.CreateCounter("test_counter", string.Empty, "label");
Assert.Throws <ArgumentOutOfRangeException>(() => counter.Inc(-1));
var labeled = counter.WithLabels("value");
Assert.Throws <ArgumentOutOfRangeException>(() => labeled.Inc(-1));
}
public void ShouldNotThrowOnRemoveByNameNonRegisteredCollector(string keyToRemove)
{
var registry = new CollectorRegistry();
var collector = new DummyCollector("collector", "metric");
registry.Add(collector);
var res = registry.Remove(keyToRemove);
Assert.Null(res);
Assert.True(registry.TryGet("collector", out var _));
}
static Metrics()
{
DefaultRegistry = new CollectorRegistry();
DefaultRegistry.SetBeforeFirstCollectCallback(delegate
{
// We include some metrics by default, just to give some output when a user first uses the library.
// These are not designed to be super meaningful/useful metrics.
DotNetStats.Register(DefaultRegistry);
});
_defaultFactory = new MetricFactory(DefaultRegistry);
}
public void DoNotCallFactoryIfCollectorExists()
{
var registry = new CollectorRegistry();
var originalCollector = new DummyCollector("testName", "metric");
var fn = Substitute.For <Func <CollectorConfiguration, ICollector> >();
registry.Add(originalCollector);
var result = registry.GetOrAdd(originalCollector.Configuration, fn);
Assert.Equal(originalCollector, result);
fn.DidNotReceiveWithAnyArgs();
}
public void Setup()
{
_registry = new CollectorRegistry();
var factory = new MetricFactory(_registry);
var summary = factory.CreateSummary("summary", string.Empty, "label");
summary.Observe(1);
summary.Observe(10);
summary.Observe(20);
summary.WithLabels("test").Observe(2);
_stream = new MemoryStream();
}
public void Init()
{
_registry = Metrics.NewCustomRegistry();
_factory = Metrics.WithCustomRegistry(_registry);
_histogram = _factory.CreateHistogram("default_histogram", "", new HistogramConfiguration
{
Buckets = new[] { 0.1d, 1d, 10d }
});
_requestDelegate = context => Task.CompletedTask;
_httpContext = new DefaultHttpContext();
_sut = new HttpRequestDurationMiddleware(_requestDelegate, _histogram);
}
public void Custom_Registry()
{
var myRegistry = new CollectorRegistry();
var counter1 = Metrics.WithCustomRegistry(myRegistry).CreateCounter("counter1", "help1"); //registered on a custom registry
var counter2 = Metrics.CreateCounter("counter1", "help1"); //created on different registry - same name is hence permitted
counter1.Inc(3);
counter2.Inc(4);
Assert.Equal(3, myRegistry.CollectAll().ToArray()[0].Metrics[0].CCounter.Value); //counter1 == 3
Assert.Equal(4, CollectorRegistry.Instance.CollectAll().ToArray()[0].Metrics[0].CCounter.Value); //counter2 == 4
}
public void Setup()
{
_registry = new CollectorRegistry();
var factory = new MetricFactory(_registry);
var histogram = factory.CreateHistogram("histogram", string.Empty, "label");
histogram.Observe(1);
histogram.Observe(10);
histogram.Observe(20);
histogram.WithLabels("test").Observe(2);
_stream = new MemoryStream();
}
public void CannotAddWithDuplicatedMetricNames(string[] first, string[] second)
{
var registry = new CollectorRegistry();
var collector1 = Substitute.For <ICollector>();
collector1.MetricNames.Returns(first);
var collector2 = Substitute.For <ICollector>();
collector2.MetricNames.Returns(second);
registry.Add("collector1", collector1);
Assert.Throws <ArgumentException>(() => registry.Add("collector1", collector2));
}
public void CannotAddDuplicatedCollectors()
{
var registry = new CollectorRegistry();
var collector = Substitute.For <ICollector>();
collector.MetricNames.Returns(new[] { "metric" });
var collector1 = Substitute.For <ICollector>();
collector1.MetricNames.Returns(new[] { "metric" });
registry.Add("testName", collector);
Assert.Throws <ArgumentException>(() => registry.Add("testName", collector1));
}
public void Init()
{
_registry = Metrics.NewCustomRegistry();
_factory = Metrics.WithCustomRegistry(_registry);
_counter = _factory.CreateCounter("default_counter", "");
_requestDelegate = context => Task.CompletedTask;
_httpContext = new DefaultHttpContext();
_sut = new GrpcRequestCountMiddleware(_requestDelegate, new GrpcRequestCountOptions
{
Counter = _counter
});
}
public void DoNotCallFactoryIfCollectorExists()
{
var registry = new CollectorRegistry();
var originalCollector = Substitute.For <ICollector>();
originalCollector.MetricNames.Returns(new[] { "metric" });
var fn = Substitute.For <Func <CollectorConfiguration, ICollector> >();
var cfg = new CollectorConfiguration("testName");
registry.Add("testName", originalCollector);
var result = registry.GetOrAdd(cfg, fn);
Assert.Equal(originalCollector, result);
fn.DidNotReceiveWithAnyArgs();
}
public void CanDecrement()
{
var registry = new CollectorRegistry();
var factory = new MetricFactory(registry);
var gauge = factory.CreateGauge("test_gauge", string.Empty, "label");
gauge.Dec(5);
var labeled = gauge.WithLabels("value");
labeled.Dec(1);
Assert.Equal(-5, gauge.Value);
Assert.Equal(-1, labeled.Value);
}
public void WithLabels()
{
var registry = new CollectorRegistry();
var factory = new MetricFactory(registry);
var untyped = factory.CreateUntyped("test_untyped", string.Empty, "label");
untyped.Set(2);
var labeled = untyped.WithLabels("value");
labeled.Set(3);
Assert.Equal(2, untyped.Value);
Assert.Equal(3, labeled.Value);
}
public void AddMetricsToRegistry(CollectorRegistry registry)
{
registry.AddBeforeCollectCallback(() =>
{
var resolverDiagnostics = resolver.Diagnostics;
ResolverFactoryCacheCount.Set(resolverDiagnostics.FactoryCacheCount);
ResolverFactoryCacheWidth.Set(resolverDiagnostics.FactoryCacheWidth);
ResolverFactoryCacheDepth.Set(resolverDiagnostics.FactoryCacheDepth);
var controllerDiagnostics = engineController.Diagnostics;
AccessorMapperCacheCount.Set(controllerDiagnostics.ResultMapperCacheCount);
AccessorMapperCacheWidth.Set(controllerDiagnostics.ResultMapperCacheWidth);
AccessorMapperCacheDepth.Set(controllerDiagnostics.ResultMapperCacheDepth);
});
}
public void WithLabels()
{
var registry = new CollectorRegistry();
var factory = new MetricFactory(registry);
var gauge = factory.CreateGauge("test_gauge", string.Empty, "label");
gauge.Inc(2);
var labeled = gauge.WithLabels("value");
labeled.Inc(3);
Assert.Equal(2, gauge.Value);
Assert.Equal(3, labeled.Value);
}
public OnDemandCollector(string sqlConnectionString, int millisecondTimeout, CollectorRegistry registry, Func <MetricFactory, IEnumerable <IQuery> > configureAction)
{
_sqlConnectionString = sqlConnectionString;
_millisecondTimeout = millisecondTimeout;
_registry = registry;
_metricFactory = Metrics.WithCustomRegistry(registry);
_registry.AddBeforeCollectCallback(UpdateMetrics);
_metrics =
configureAction(_metricFactory)
.Append(new ConnectionUp(_metricFactory))
.ToArray();
_exceptionsGauge = _metricFactory.CreateGauge("mssql_exceptions", "Number of queries throwing exceptions.");
_timeoutGauge = _metricFactory.CreateGauge("mssql_timeouts", "Number of queries timing out.");
}
public void SameLabelsProducesSameMetric_StringAndTuple()
{
var registry = new CollectorRegistry();
var factory = new MetricFactory(registry);
var counter1 = factory.CreateCounter("test_counter", string.Empty, "label1", "label2");
counter1.Unlabelled.Inc();
var counter2 = factory.CreateCounter("test_counter", string.Empty, ("label1", "label2"));
counter2.Unlabelled.Inc();
// Cannot compare metrics families, because of different contracts, should check if sample the same
Assert.Equal(counter1.Unlabelled, counter2.Unlabelled);
}
public void WithLabels()
{
var registry = new CollectorRegistry();
var factory = new MetricFactory(registry);
var counter = factory.CreateCounter("test_counter", string.Empty, "label");
counter.Inc(2);
var labeled = counter.WithLabels("value");
labeled.Inc(3);
Assert.Equal(2, counter.Value);
Assert.Equal(3, labeled.Value);
}
public PrometheusExporterTests()
{
_autoFixture = new Fixture();
_mockHangfireMonitor = new Mock <IHangfireMonitorService>();
_collectorRegistry = Metrics.NewCustomRegistry();
_settings = new HangfirePrometheusSettings
{
CollectorRegistry = _collectorRegistry
};
_classUnderTest = new HangfirePrometheusExporter(_mockHangfireMonitor.Object, _settings);
}
private static IEnumerable <ExposedMetric> GetExposedMetric(SourceAndConfig source)
{
Console.WriteLine($"Getting metrics for {source}..");
// Start collector
var registry = new CollectorRegistry();
using var statsCollector = source.ApplyConfig(DotNetRuntimeStatsBuilder.Customize()).StartCollecting(registry);
// Wait for metrics to be available (hacky!)
Thread.Sleep(1500);
// Pull registered collectors
var collectors = registry.TryGetFieldValue("_collectors", Flags.InstancePrivate) as ConcurrentDictionary <string, Collector>;
return(collectors.Values.Select(c => new ExposedMetric(c, source.Source)));
}
public void MetricsWriterApiUsage()
{
var writer = Substitute.For <IMetricsWriter>();
var registry = new CollectorRegistry();
var factory = new MetricFactory(registry);
var histogram1 = CreateHistogram1(factory);
histogram1.Collect(writer);
Received.InOrder(() =>
{
writer.StartMetric("hist1");
writer.WriteHelp("help");
writer.WriteType(MetricType.Histogram);
var sample = writer.StartSample("_bucket");
var lbl = sample.StartLabels();
lbl.WriteLabel("le", "1");
lbl.EndLabels();
sample.WriteValue(2);
sample = writer.StartSample("_bucket");
lbl = sample.StartLabels();
lbl.WriteLabel("le", "2");
lbl.EndLabels();
sample.WriteValue(5);
sample = writer.StartSample("_bucket");
lbl = sample.StartLabels();
lbl.WriteLabel("le", "3");
lbl.EndLabels();
sample.WriteValue(8);
sample = writer.StartSample("_bucket");
lbl = sample.StartLabels();
lbl.WriteLabel("le", "+Inf");
lbl.EndLabels();
sample.WriteValue(9);
sample = writer.StartSample("_sum");
sample.WriteValue(16.7);
sample = writer.StartSample("_count");
sample.WriteValue(9);
});
}
public void CanRemoveCollector()
{
var registry = new CollectorRegistry();
var collector = Substitute.For <ICollector>();
collector.MetricNames.Returns(new[] { "metric" });
registry.Add("collector", collector);
var collector1 = Substitute.For <ICollector>();
collector1.MetricNames.Returns(new[] { "metric1" });
registry.Add("metric1", collector1);
registry.Remove("metric1");
Assert.True(registry.Enumerate().SequenceEqual(new[] { collector }));
}
public void CanRemoveCollector()
{
var registry = new CollectorRegistry();
var collector = new DummyCollector("collector", "metric");
registry.Add(collector);
var collector1 = new DummyCollector("collector1", "metric1");
registry.Add(collector1);
var res = registry.Remove(collector1);
Assert.True(res);
Assert.False(registry.TryGet("collector1", out var _));
Assert.True(registry.TryGet("collector", out var _));
}
public void Check_AddMetricFactory_Custom_CollectorRegistry()
{
var collectorRegistry = new CollectorRegistry();
var serviceCollection = new ServiceCollection();
serviceCollection.AddMetricFactory(collectorRegistry);
var serviceProvider = serviceCollection.BuildServiceProvider();
var metrricFactory = serviceProvider.GetService <IMetricFactory>();
Assert.NotNull(metrricFactory);
var actualCollectorRegistry = serviceProvider.GetService <ICollectorRegistry>();
Assert.Equal(collectorRegistry, actualCollectorRegistry);
Assert.NotEqual(Metrics.DefaultCollectorRegistry, actualCollectorRegistry);
}
public void CanEnumerateCollectors(int count)
{
var registry = new CollectorRegistry();
var collectors = new List <ICollector>();
for (var i = 0; i < count; i++)
{
var collector = Substitute.For <ICollector>();
var name = $"metric{i}";
collector.MetricNames.Returns(new[] { name });
registry.Add(name, collector);
collectors.Add(collector);
}
Assert.True(registry.Enumerate().SequenceEqual(collectors));
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args, IConfigure configurationBinding,
CollectorRegistry registry)
{
var defaultPath =
"/" + configurationBinding.ServerPath.Replace("/", string.Empty,
StringComparison.CurrentCultureIgnoreCase);
if (defaultPath.Equals("/", StringComparison.CurrentCultureIgnoreCase))
{
defaultPath = string.Empty;
}
return(WebHost.CreateDefaultBuilder(args)
.UseSerilog()
.Configure(app => app.UseMetricServer(defaultPath, registry))
.UseUrls($"http://*:{configurationBinding.ServerPort}"));
}
