Esempio n. 1
0
 /// <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));
     }
 }
Esempio n. 2
0
        /// <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));
            }
        }