/// <summary>
/// Asserts that the NumOps and quantiles for a metric have been changed at
/// some point to a non-zero value.
/// </summary>
/// <param name="prefix">of the metric</param>
/// <param name="rb">MetricsRecordBuilder with the metric</param>
public static void AssertQuantileGauges(string prefix, MetricsRecordBuilder rb)
{
Org.Mockito.Mockito.Verify(rb).AddGauge(EqName(Interns.Info(prefix + "NumOps", string.Empty
)), AdditionalMatchers.Geq(0l));
foreach (Quantile q in MutableQuantiles.quantiles)
{
string nameTemplate = prefix + "%dthPercentileLatency";
int percentile = (int)(100 * q.quantile);
Org.Mockito.Mockito.Verify(rb).AddGauge(EqName(Interns.Info(string.Format(nameTemplate
, percentile), string.Empty)), AdditionalMatchers.Geq(0l));
}
}
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>
/// 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));
}
}
/// <summary>
/// the test creates 2 electors which try to become active using a real
/// zookeeper server.
/// </summary>
/// <remarks>
/// the test creates 2 electors which try to become active using a real
/// zookeeper server. It verifies that 1 becomes active and 1 becomes standby.
/// Upon becoming active the leader quits election and the test verifies that
/// the standby now becomes active.
/// </remarks>
/// <exception cref="System.Exception"/>
public virtual void TestActiveStandbyTransition()
{
Log.Info("starting test with parentDir:" + ParentDir);
NUnit.Framework.Assert.IsFalse(electors[0].ParentZNodeExists());
electors[0].EnsureParentZNode();
Assert.True(electors[0].ParentZNodeExists());
// First elector joins election, becomes active.
electors[0].JoinElection(appDatas[0]);
ActiveStandbyElectorTestUtil.WaitForActiveLockData(null, zkServer, ParentDir, appDatas
[0]);
Org.Mockito.Mockito.Verify(cbs[0], Org.Mockito.Mockito.Timeout(1000)).BecomeActive
();
CheckFatalsAndReset();
// Second elector joins election, becomes standby.
electors[1].JoinElection(appDatas[1]);
Org.Mockito.Mockito.Verify(cbs[1], Org.Mockito.Mockito.Timeout(1000)).BecomeStandby
();
CheckFatalsAndReset();
// First elector quits, second one should become active
electors[0].QuitElection(true);
ActiveStandbyElectorTestUtil.WaitForActiveLockData(null, zkServer, ParentDir, appDatas
[1]);
Org.Mockito.Mockito.Verify(cbs[1], Org.Mockito.Mockito.Timeout(1000)).BecomeActive
();
CheckFatalsAndReset();
// First one rejoins, becomes standby, second one stays active
electors[0].JoinElection(appDatas[0]);
Org.Mockito.Mockito.Verify(cbs[0], Org.Mockito.Mockito.Timeout(1000)).BecomeStandby
();
CheckFatalsAndReset();
// Second one expires, first one becomes active
electors[1].PreventSessionReestablishmentForTests();
try
{
zkServer.CloseSession(electors[1].GetZKSessionIdForTests());
ActiveStandbyElectorTestUtil.WaitForActiveLockData(null, zkServer, ParentDir, appDatas
[0]);
Org.Mockito.Mockito.Verify(cbs[1], Org.Mockito.Mockito.Timeout(1000)).EnterNeutralMode
();
Org.Mockito.Mockito.Verify(cbs[0], Org.Mockito.Mockito.Timeout(1000)).FenceOldActive
(AdditionalMatchers.AryEq(appDatas[1]));
Org.Mockito.Mockito.Verify(cbs[0], Org.Mockito.Mockito.Timeout(1000)).BecomeActive
();
}
finally
{
electors[1].AllowSessionReestablishmentForTests();
}
// Second one eventually reconnects and becomes standby
Org.Mockito.Mockito.Verify(cbs[1], Org.Mockito.Mockito.Timeout(5000)).BecomeStandby
();
CheckFatalsAndReset();
// First one expires, second one should become active
electors[0].PreventSessionReestablishmentForTests();
try
{
zkServer.CloseSession(electors[0].GetZKSessionIdForTests());
ActiveStandbyElectorTestUtil.WaitForActiveLockData(null, zkServer, ParentDir, appDatas
[1]);
Org.Mockito.Mockito.Verify(cbs[0], Org.Mockito.Mockito.Timeout(1000)).EnterNeutralMode
();
Org.Mockito.Mockito.Verify(cbs[1], Org.Mockito.Mockito.Timeout(1000)).FenceOldActive
(AdditionalMatchers.AryEq(appDatas[0]));
Org.Mockito.Mockito.Verify(cbs[1], Org.Mockito.Mockito.Timeout(1000)).BecomeActive
();
}
finally
{
electors[0].AllowSessionReestablishmentForTests();
}
CheckFatalsAndReset();
}
