public virtual void TestMutableRates()
{
MetricsRecordBuilder rb = MetricsAsserts.MockMetricsRecordBuilder();
MetricsRegistry registry = new MetricsRegistry("test");
MutableRates rates = new MutableRates(registry);
rates.Init(typeof(TestMutableMetrics.TestProtocol));
registry.Snapshot(rb, false);
MetricsAsserts.AssertCounter("FooNumOps", 0L, rb);
MetricsAsserts.AssertGauge("FooAvgTime", 0.0, rb);
MetricsAsserts.AssertCounter("BarNumOps", 0L, rb);
MetricsAsserts.AssertGauge("BarAvgTime", 0.0, rb);
}
internal virtual MutableMetric NewForMethod(object source, MethodInfo method, Metric
annotation, MetricsRegistry registry)
{
if (Log.IsDebugEnabled())
{
Log.Debug("method " + method + " with annotation " + annotation);
}
MetricsInfo info = GetInfo(annotation, method);
MutableMetric metric = NewForMethod(source, method, annotation);
metric = metric != null ? metric : new MethodMetric(source, method, info, annotation
.Type());
registry.Add(info.Name(), metric);
return(metric);
}
public virtual void TestAddByName()
{
MetricsRecordBuilder rb = MetricsAsserts.MockMetricsRecordBuilder();
MetricsRegistry r = new MetricsRegistry("test");
r.Add("s1", 42);
r.Get("s1").Snapshot(rb);
Org.Mockito.Mockito.Verify(rb).AddCounter(Interns.Info("S1NumOps", "Number of ops for s1"
), 1L);
Org.Mockito.Mockito.Verify(rb).AddGauge(Interns.Info("S1AvgTime", "Average time for s1"
), 42.0);
r.NewCounter("c1", "test add", 1);
r.NewGauge("g1", "test add", 1);
ExpectMetricsException("Unsupported add", new _Runnable_114(r));
ExpectMetricsException("Unsupported add", new _Runnable_119(r));
}
/// <summary>
/// Ensure that quantile estimates from
/// <see cref="MutableQuantiles"/>
/// are within
/// specified error bounds.
/// </summary>
/// <exception cref="System.Exception"/>
public virtual void TestMutableQuantilesError()
{
MetricsRecordBuilder mb = MetricsAsserts.MockMetricsRecordBuilder();
MetricsRegistry registry = new MetricsRegistry("test");
// Use a 5s rollover period
MutableQuantiles quantiles = registry.NewQuantiles("foo", "stat", "Ops", "Latency"
, 5);
// Push some values in and wait for it to publish
long start = Runtime.NanoTime() / 1000000;
for (long i = 1; i <= 1000; i++)
{
quantiles.Add(i);
quantiles.Add(1001 - i);
}
long end = Runtime.NanoTime() / 1000000;
Thread.Sleep(6000 - (end - start));
registry.Snapshot(mb, false);
// Print out the snapshot
IDictionary <Quantile, long> previousSnapshot = quantiles.previousSnapshot;
foreach (KeyValuePair <Quantile, long> item in previousSnapshot)
{
System.Console.Out.WriteLine(string.Format("Quantile %.2f has value %d", item.Key
.quantile, item.Value));
}
// Verify the results are within our requirements
Org.Mockito.Mockito.Verify(mb).AddGauge(Interns.Info("FooNumOps", "Number of ops for stat with 5s interval"
), (long)2000);
Quantile[] quants = MutableQuantiles.quantiles;
string name = "Foo%dthPercentileLatency";
string desc = "%d percentile latency with 5 second interval for stat";
foreach (Quantile q in quants)
{
int percentile = (int)(100 * q.quantile);
int error = (int)(1000 * q.error);
string n = string.Format(name, percentile);
string d = string.Format(desc, percentile);
long expected = (long)(q.quantile * 1000);
Org.Mockito.Mockito.Verify(mb).AddGauge(Matchers.Eq(Interns.Info(n, d)), AdditionalMatchers.Leq
(expected + error));
Org.Mockito.Mockito.Verify(mb).AddGauge(Matchers.Eq(Interns.Info(n, d)), AdditionalMatchers.Geq
(expected - error));
}
}
public virtual void TestSnapshot()
{
MetricsRecordBuilder mb = MetricsAsserts.MockMetricsRecordBuilder();
MetricsRegistry registry = new MetricsRegistry("test");
registry.NewCounter("c1", "int counter", 1);
registry.NewCounter("c2", "long counter", 2L);
registry.NewGauge("g1", "int gauge", 3);
registry.NewGauge("g2", "long gauge", 4L);
registry.NewStat("s1", "stat", "Ops", "Time", true).Add(0);
registry.NewRate("s2", "stat", false).Add(0);
registry.Snapshot(mb, true);
MutableStat s2 = (MutableStat)registry.Get("s2");
s2.Snapshot(mb, true);
// should get the same back.
s2.Add(1);
s2.Snapshot(mb, true);
// should get new interval values back
Org.Mockito.Mockito.Verify(mb).AddCounter(Interns.Info("c1", "int counter"), 1);
Org.Mockito.Mockito.Verify(mb).AddCounter(Interns.Info("c2", "long counter"), 2L);
Org.Mockito.Mockito.Verify(mb).AddGauge(Interns.Info("g1", "int gauge"), 3);
Org.Mockito.Mockito.Verify(mb).AddGauge(Interns.Info("g2", "long gauge"), 4L);
Org.Mockito.Mockito.Verify(mb).AddCounter(Interns.Info("S1NumOps", "Number of ops for stat"
), 1L);
Org.Mockito.Mockito.Verify(mb).AddGauge(Matchers.Eq(Interns.Info("S1AvgTime", "Average time for stat"
)), AdditionalMatchers.Eq(0.0, Epsilon));
Org.Mockito.Mockito.Verify(mb).AddGauge(Matchers.Eq(Interns.Info("S1StdevTime", "Standard deviation of time for stat"
)), AdditionalMatchers.Eq(0.0, Epsilon));
Org.Mockito.Mockito.Verify(mb).AddGauge(Matchers.Eq(Interns.Info("S1IMinTime", "Interval min time for stat"
)), AdditionalMatchers.Eq(0.0, Epsilon));
Org.Mockito.Mockito.Verify(mb).AddGauge(Matchers.Eq(Interns.Info("S1IMaxTime", "Interval max time for stat"
)), AdditionalMatchers.Eq(0.0, Epsilon));
Org.Mockito.Mockito.Verify(mb).AddGauge(Matchers.Eq(Interns.Info("S1MinTime", "Min time for stat"
)), AdditionalMatchers.Eq(0.0, Epsilon));
Org.Mockito.Mockito.Verify(mb).AddGauge(Matchers.Eq(Interns.Info("S1MaxTime", "Max time for stat"
)), AdditionalMatchers.Eq(0.0, Epsilon));
Org.Mockito.Mockito.Verify(mb, Org.Mockito.Mockito.Times(2)).AddCounter(Interns.Info
("S2NumOps", "Number of ops for stat"), 1L);
Org.Mockito.Mockito.Verify(mb, Org.Mockito.Mockito.Times(2)).AddGauge(Matchers.Eq
(Interns.Info("S2AvgTime", "Average time for stat")), AdditionalMatchers.Eq(0.0,
Epsilon));
Org.Mockito.Mockito.Verify(mb).AddCounter(Interns.Info("S2NumOps", "Number of ops for stat"
), 2L);
Org.Mockito.Mockito.Verify(mb).AddGauge(Matchers.Eq(Interns.Info("S2AvgTime", "Average time for stat"
)), AdditionalMatchers.Eq(1.0, Epsilon));
}
/// <summary>
/// Test that
/// <see cref="MutableQuantiles"/>
/// rolls the window over at the specified
/// interval.
/// </summary>
/// <exception cref="System.Exception"/>
public virtual void TestMutableQuantilesRollover()
{
MetricsRecordBuilder mb = MetricsAsserts.MockMetricsRecordBuilder();
MetricsRegistry registry = new MetricsRegistry("test");
// Use a 5s rollover period
MutableQuantiles quantiles = registry.NewQuantiles("foo", "stat", "Ops", "Latency"
, 5);
Quantile[] quants = MutableQuantiles.quantiles;
string name = "Foo%dthPercentileLatency";
string desc = "%d percentile latency with 5 second interval for stat";
// Push values for three intervals
long start = Runtime.NanoTime() / 1000000;
for (int i = 1; i <= 3; i++)
{
// Insert the values
for (long j = 1; j <= 1000; j++)
{
quantiles.Add(i);
}
// Sleep until 1s after the next 5s interval, to let the metrics
// roll over
long sleep = (start + (5000 * i) + 1000) - (Runtime.NanoTime() / 1000000);
Thread.Sleep(sleep);
// Verify that the window reset, check it has the values we pushed in
registry.Snapshot(mb, false);
foreach (Quantile q in quants)
{
int percentile = (int)(100 * q.quantile);
string n = string.Format(name, percentile);
string d = string.Format(desc, percentile);
Org.Mockito.Mockito.Verify(mb).AddGauge(Interns.Info(n, d), (long)i);
}
}
// Verify the metrics were added the right number of times
Org.Mockito.Mockito.Verify(mb, Org.Mockito.Mockito.Times(3)).AddGauge(Interns.Info
("FooNumOps", "Number of ops for stat with 5s interval"), (long)1000);
foreach (Quantile q_1 in quants)
{
int percentile = (int)(100 * q_1.quantile);
string n = string.Format(name, percentile);
string d = string.Format(desc, percentile);
Org.Mockito.Mockito.Verify(mb, Org.Mockito.Mockito.Times(3)).AddGauge(Matchers.Eq
(Interns.Info(n, d)), Matchers.AnyLong());
}
}
/// <summary>
/// Test that
/// <see cref="MutableQuantiles"/>
/// rolls over correctly even if no items
/// have been added to the window
/// </summary>
/// <exception cref="System.Exception"/>
public virtual void TestMutableQuantilesEmptyRollover()
{
MetricsRecordBuilder mb = MetricsAsserts.MockMetricsRecordBuilder();
MetricsRegistry registry = new MetricsRegistry("test");
// Use a 5s rollover period
MutableQuantiles quantiles = registry.NewQuantiles("foo", "stat", "Ops", "Latency"
, 5);
// Check it initially
quantiles.Snapshot(mb, true);
Org.Mockito.Mockito.Verify(mb).AddGauge(Interns.Info("FooNumOps", "Number of ops for stat with 5s interval"
), (long)0);
Thread.Sleep(6000);
quantiles.Snapshot(mb, false);
Org.Mockito.Mockito.Verify(mb, Org.Mockito.Mockito.Times(2)).AddGauge(Interns.Info
("FooNumOps", "Number of ops for stat with 5s interval"), (long)0);
}
public virtual void TestNewMetrics()
{
MetricsRegistry r = new MetricsRegistry("test");
r.NewCounter("c1", "c1 desc", 1);
r.NewCounter("c2", "c2 desc", 2L);
r.NewGauge("g1", "g1 desc", 3);
r.NewGauge("g2", "g2 desc", 4L);
r.NewStat("s1", "s1 desc", "ops", "time");
Assert.Equal("num metrics in registry", 5, r.Metrics().Count);
Assert.True("c1 found", r.Get("c1") is MutableCounterInt);
Assert.True("c2 found", r.Get("c2") is MutableCounterLong);
Assert.True("g1 found", r.Get("g1") is MutableGaugeInt);
Assert.True("g2 found", r.Get("g2") is MutableGaugeLong);
Assert.True("s1 found", r.Get("s1") is MutableStat);
ExpectMetricsException("Metric name c1 already exists", new _Runnable_54(r));
}
private MetricsRegistry InitRegistry(object source)
{
Type cls = source.GetType();
MetricsRegistry r = null;
// Get the registry if it already exists.
foreach (FieldInfo field in ReflectionUtils.GetDeclaredFieldsIncludingInherited(cls
))
{
if (field.FieldType != typeof(MetricsRegistry))
{
continue;
}
try
{
r = (MetricsRegistry)field.GetValue(source);
hasRegistry = r != null;
break;
}
catch (Exception e)
{
Log.Warn("Error accessing field " + field, e);
continue;
}
}
// Create a new registry according to annotation
foreach (Annotation.Annotation annotation in cls.GetAnnotations())
{
if (annotation is Metrics)
{
Metrics ma = (Metrics)annotation;
info = factory.GetInfo(cls, ma);
if (r == null)
{
r = new MetricsRegistry(info);
}
r.SetContext(ma.Context());
}
}
if (r == null)
{
return(new MetricsRegistry(cls.Name));
}
return(r);
}
internal MetricsSourceBuilder(object source, MutableMetricsFactory factory)
{
this.source = Preconditions.CheckNotNull(source, "source");
this.factory = Preconditions.CheckNotNull(factory, "mutable metrics factory");
Type cls = source.GetType();
registry = InitRegistry(source);
foreach (FieldInfo field in ReflectionUtils.GetDeclaredFieldsIncludingInherited(cls
))
{
Add(source, field);
}
foreach (MethodInfo method in ReflectionUtils.GetDeclaredMethodsIncludingInherited
(cls))
{
Add(source, method);
}
}
public virtual void TestMetricsRegistryIllegalMetricNames()
{
MetricsRegistry r = new MetricsRegistry("test");
// Fill up with some basics
r.NewCounter("c1", "c1 desc", 1);
r.NewGauge("g1", "g1 desc", 1);
r.NewQuantiles("q1", "q1 desc", "q1 name", "q1 val type", 1);
// Add some illegal names
ExpectMetricsException("Metric name 'badcount 2' contains " + "illegal whitespace character"
, new _Runnable_72(r));
ExpectMetricsException("Metric name 'badcount3 ' contains " + "illegal whitespace character"
, new _Runnable_77(r));
ExpectMetricsException("Metric name ' badcount4' contains " + "illegal whitespace character"
, new _Runnable_82(r));
ExpectMetricsException("Metric name 'withtab5 ' contains "+ "illegal whitespace character"
, new _Runnable_87(r));
ExpectMetricsException("Metric name 'withnewline6\n' contains " + "illegal whitespace character"
, new _Runnable_92(r));
// Final validation
Assert.Equal("num metrics in registry", 3, r.Metrics().Count);
}
internal MutableRates(MetricsRegistry registry)
{
this.registry = Preconditions.CheckNotNull(registry, "metrics registry");
}
internal virtual MutableMetric NewForField(FieldInfo field, Metric annotation, MetricsRegistry
registry)
{
if (Log.IsDebugEnabled())
{
Log.Debug("field " + field + " with annotation " + annotation);
}
MetricsInfo info = GetInfo(annotation, field);
MutableMetric metric = NewForField(field, annotation);
if (metric != null)
{
registry.Add(info.Name(), metric);
return(metric);
}
Type cls = field.FieldType;
if (cls == typeof(MutableCounterInt))
{
return(registry.NewCounter(info, 0));
}
if (cls == typeof(MutableCounterLong))
{
return(registry.NewCounter(info, 0L));
}
if (cls == typeof(MutableGaugeInt))
{
return(registry.NewGauge(info, 0));
}
if (cls == typeof(MutableGaugeLong))
{
return(registry.NewGauge(info, 0L));
}
if (cls == typeof(MutableRate))
{
return(registry.NewRate(info.Name(), info.Description(), annotation.Always()));
}
if (cls == typeof(MutableRates))
{
return(new MutableRates(registry));
}
if (cls == typeof(MutableStat))
{
return(registry.NewStat(info.Name(), info.Description(), annotation.SampleName(),
annotation.ValueName(), annotation.Always()));
}
throw new MetricsException("Unsupported metric field " + field.Name + " of type "
+ field.FieldType.FullName);
}
public _Runnable_77(MetricsRegistry r)
{
this.r = r;
}