public void ShouldNotCrashWhenEventRecordAfterDisposed()
{
var sink = new DictionarySink();
var e = new MetricsCollector(sink, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5));
e.IncrementCounter("myCounter");
e.Dispose();
Assert.Single(sink.Counters);
e.IncrementCounter("myCounter");
}
public void ShouldFlushOnDispose()
{
var clock = new DummyClock("11:00:00.000");
var sink = new DictionarySink();
using (var e = new MetricsCollector(sink, clock, oneSecond, TimeSpan.FromSeconds(5), false))
{
clock.Set("12:00:01.500");
// 10000 events per second for 10 virtual seconds, using 3 threads
var options = new ParallelOptions {
MaxDegreeOfParallelism = 5
};
for (int i = 0; i < 10; i++)
{
Parallel.For(0, 10000, options, (j, s) =>
{
e.IncrementCounter($"myevent-{Thread.CurrentThread.ManagedThreadId}");
});
clock.Advance(oneSecond);
}
}
// Dispose method on event collect ensures all events are flushed immediately
Assert.Equal(100000, sink.Counters.Values.Sum());
}
public void TestCounters()
{
var collector = new MetricsCollector();
const string numOfExceptionsMetricName = "NumOfExceptions";
const string succeededMetricName = "Succeeded";
collector.IncrementCounter(numOfExceptionsMetricName, 0);
collector.IncrementCounter(numOfExceptionsMetricName, 1);
collector.IncrementCounter(succeededMetricName, 1);
collector.IncrementCounter(succeededMetricName, 2);
var metrics = collector.GetMetrics();
Assert.Equal(2, metrics.Count);
Assert.Equal("1", metrics[numOfExceptionsMetricName].FlushToString());
Assert.Equal("3", metrics[succeededMetricName].FlushToString());
}
public void CrossMetricMergesAreNotAllowed()
{
var collector = new MetricsCollector();
collector.IncrementCounter("Counter", 1);
var collector2 = new MetricsCollector();
collector2.Record("Counter", 10M, Unit.Second);
collector.Merge(collector2);
}
public void CollectorShouldIgnoreInvalidMetricNames()
{
var collector = new MetricsCollector();
const string invalidName = "Invalid@Name";
collector.IncrementCounter(invalidName, 1);
using (collector.StartTimer(invalidName))
{
collector.Record(invalidName, 0, Unit.None);
}
Assert.Equal(string.Empty, collector.FlushToString());
}
public void MergeOfTwoCollectorsShouldWork()
{
var collector1 = new MetricsCollector();
var collector2 = new MetricsCollector();
collector1.IncrementCounter("Counter", 1);
collector2.IncrementCounter("Counter", 10);
collector1.Merge(collector2);
var flushed = collector1.FlushToString();
Assert.Equal("m.Counter=11", flushed);
}
public void Run(IConfigurationRoot configuration)
{
var sink = ChooseSink();
var metricsWriterSettings = configuration.GetSection("MetricsWriter").Get <MetricsWriterSettings>();
var metricsCollectorSettings = configuration.GetSection("MetricsCollector").Get <MetricsCollectorSettings>();
if (sink is IDatabasePlugin databasePlugin)
{
var databaseConnectionSettings = configuration.GetSection("Database:Connection").Get <DatabaseConnectionSettings>();
var databaseTablesSettings = configuration.GetSection("Database:Tables").Get <DatabaseTablesSettings>();
databasePlugin.Initialize(databaseConnectionSettings, databaseTablesSettings, metricsWriterSettings);
}
using (var metrics = new MetricsCollector(sink, metricsCollectorSettings))
{
Console.WriteLine("Press some keys; enter to exit");
metrics.RegisterThresholds("latency", new int[] { 0, 50, 75, 100, 1000, 2000, 10000 });
var stopwatch = new Stopwatch();
char key;
do
{
stopwatch.Start();
key = Console.ReadKey(true).KeyChar;
stopwatch.Stop();
metrics.IncrementCounter(key.ToString());
metrics.IncrementBucket("latency", stopwatch.ElapsedMilliseconds);
metrics.Event(key.ToString());
// letters a-z: lowercase is start of interval, uppercase is end.
if (key >= 'a' && key <= 'z')
{
metrics.StartInterval("session", key.ToString());
}
else if (key >= 'A' && key <= 'Z')
{
metrics.EndInterval("session", key.ToString().ToLower());
}
stopwatch.Reset();
} while (key != '\r' && key != '\n');
}
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public void ShouldCountEventsFromMultipleThreads()
{
var sink = new DictionarySink();
using (var e = new MetricsCollector(sink, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(200)))
{
var options = new ParallelOptions {
MaxDegreeOfParallelism = 5
};
Parallel.For(0, 100000, options, (j, s) =>
{
e.IncrementCounter($"mycounter-{Thread.CurrentThread.ManagedThreadId}");
});
}
Assert.Equal(100000, sink.Counters.Values.Sum());
}
public void EventShouldFlushAtMultiplesOf5000ms()
{
var clock = new DummyClock("11:00:00.000");
var sink = new DictionarySink();
using (var e = new MetricsCollector(sink, clock, oneSecond, TimeSpan.FromSeconds(5), false))
{
clock.Set("12:00:04.000");
e.IncrementCounter("myevent");
// should not fire event yet
clock.Set("12:00:04.999");
Assert.Empty(sink.Counters);
clock.Set("12:00:05.000");
// should now fire event on another thread and then return
Assert.Single(sink.Counters);
}
}
public void IncrementCounter() => metrics.IncrementCounter(names[random.Next() % 50]);