Example usage for org.apache.commons.math3.stat.descriptive.summary Sum increment

Introduction

In this page you can find the example usage for org.apache.commons.math3.stat.descriptive.summary Sum increment.

Prototype

@Override
public void increment(final double d) 

Source Link

Usage

From source file:org.apereo.portal.events.aggr.JpaStatisticalSummaryTest.java

@Ignore
@Test/*from w  w  w. java 2s .  com*/
public void testSummaryStatisticsJson() throws Exception {
    final SecondMoment secondMoment = new SecondMoment();
    final Sum sum = new Sum();
    final SumOfSquares sumsq = new SumOfSquares();
    final Min min = new Min();
    final Max max = new Max();
    final SumOfLogs sumLog = new SumOfLogs();

    final Random r = new Random(0);
    for (int i = 0; i < 10; i++) {
        final int nextInt = r.nextInt(100000000);
        secondMoment.increment(nextInt);
        sum.increment(nextInt);
        sumsq.increment(nextInt);
        min.increment(nextInt);
        max.increment(nextInt);
        sumLog.increment(nextInt);
    }

    testStorelessUnivariateStatistic(secondMoment, 7.513432791665536E15);
    testStorelessUnivariateStatistic(sum, 6.01312177E8);
    testStorelessUnivariateStatistic(sumsq, 4.3671066212513456E16);
    testStorelessUnivariateStatistic(min, 2116447.0);
    testStorelessUnivariateStatistic(max, 8.5505948E7);
    testStorelessUnivariateStatistic(sumLog, 175.91713800250577);
}

---

From source file:org.hawkular.metrics.core.service.metrics.BaseMetricsITest.java

protected <T extends Number> NumericBucketPoint createSingleBucket(List<? extends DataPoint<T>> combinedData,
        DateTime start, DateTime end) {/*w  ww.jav  a2s .  c  o  m*/
    T expectedMin = combinedData.stream()
            .min((x, y) -> Double.compare(x.getValue().doubleValue(), y.getValue().doubleValue())).get()
            .getValue();
    T expectedMax = combinedData.stream()
            .max((x, y) -> Double.compare(x.getValue().doubleValue(), y.getValue().doubleValue())).get()
            .getValue();
    PercentileWrapper expectedMedian = NumericDataPointCollector.createPercentile.apply(50.0);
    Mean expectedAverage = new Mean();
    Sum expectedSamples = new Sum();
    Sum expectedSum = new Sum();
    combinedData.stream().forEach(arg -> {
        expectedMedian.addValue(arg.getValue().doubleValue());
        expectedAverage.increment(arg.getValue().doubleValue());
        expectedSamples.increment(1);
        expectedSum.increment(arg.getValue().doubleValue());
    });

    return new NumericBucketPoint.Builder(start.getMillis(), end.getMillis()).setMin(expectedMin.doubleValue())
            .setMax(expectedMax.doubleValue()).setAvg(expectedAverage.getResult())
            .setMedian(expectedMedian.getResult()).setSum(expectedSum.getResult())
            .setSamples(new Double(expectedSamples.getResult()).intValue()).build();
}

---

From source file:org.hawkular.metrics.core.service.metrics.CounterITest.java

@Test
public void findSimpleCounterStats() {
    //Setup the counter data
    NumericDataPointCollector.createPercentile = InMemoryPercentileWrapper::new;

    Random r = new Random(123);
    List<Long> randomList = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
        randomList.add((long) r.nextInt(100));
    }//from w  ww.j a  v  a2s. com
    Collections.sort(randomList);
    Iterator<Long> randoms = randomList.iterator();

    String tenantId = "findCounterStats";
    DateTime start = now().minusMinutes(10);

    Metric<Long> c1 = new Metric<>(new MetricId<>(tenantId, COUNTER, "C1"),
            asList(new DataPoint<>(start.getMillis(), 222L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(1).getMillis(), 224L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(2).getMillis(), 226L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(3).getMillis(), 228L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(4).getMillis(), 229L + randoms.next())));
    doAction(() -> metricsService.addDataPoints(COUNTER, Observable.just(c1)));
    doAction(() -> metricsService.addTags(c1, ImmutableMap.of("type", "counter_cpu_usage", "node", "server1")));

    Metric<Long> c2 = new Metric<>(new MetricId<>(tenantId, COUNTER, "C2"),
            asList(new DataPoint<>(start.getMillis(), 150L),
                    new DataPoint<>(start.plusMinutes(1).getMillis(), 153L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(2).getMillis(), 156L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(3).getMillis(), 159L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(4).getMillis(), 162L + randoms.next())));
    doAction(() -> metricsService.addDataPoints(COUNTER, Observable.just(c2)));
    doAction(() -> metricsService.addTags(c2, ImmutableMap.of("type", "counter_cpu_usage", "node", "server2")));

    Metric<Long> c3 = new Metric<>(new MetricId<>(tenantId, COUNTER, "C3"),
            asList(new DataPoint<>(start.getMillis(), 11456L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(1).getMillis(), 183332L + randoms.next())));
    doAction(() -> metricsService.addDataPoints(COUNTER, Observable.just(c3)));
    doAction(() -> metricsService.addTags(c3, ImmutableMap.of("type", "counter_cpu_usage", "node", "server3")));

    Buckets buckets = Buckets.fromCount(start.getMillis(), start.plusMinutes(5).getMillis(), 1);
    Map<String, String> tagFilters = ImmutableMap.of("type", "counter_cpu_usage", "node", "server1|server2");

    List<DataPoint<Double>> c1Rate = getOnNextEvents(() -> metricsService.findRateData(c1.getMetricId(),
            start.getMillis(), start.plusMinutes(5).getMillis(), 0, Order.ASC));

    List<DataPoint<Double>> c2Rate = getOnNextEvents(() -> metricsService.findRateData(c2.getMetricId(),
            start.getMillis(), start.plusMinutes(5).getMillis(), 0, Order.ASC));

    //Test simple counter stats
    List<List<NumericBucketPoint>> actualCounterStatsByTag = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER, tagFilters, start.getMillis(),
                    start.plusMinutes(5).getMillis(), buckets, emptyList(), false));
    assertEquals(actualCounterStatsByTag.size(), 1);

    List<List<NumericBucketPoint>> actualCounterStatsById = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER, asList("C1", "C2"),
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, emptyList(), false));
    assertEquals(actualCounterStatsById.size(), 1);

    List<NumericBucketPoint> expectedCounterStats = Arrays
            .asList(createSingleBucket(Stream.concat(c1.getDataPoints().stream(), c2.getDataPoints().stream())
                    .collect(Collectors.toList()), start, start.plusMinutes(5)));

    assertNumericBucketsEquals(actualCounterStatsByTag.get(0), expectedCounterStats);
    assertNumericBucketsEquals(actualCounterStatsById.get(0), expectedCounterStats);

    //Test stacked counter stats
    List<List<NumericBucketPoint>> actualStackedCounterStatsByTag = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER, tagFilters, start.getMillis(),
                    start.plusMinutes(5).getMillis(), buckets, emptyList(), true));
    assertEquals(actualStackedCounterStatsByTag.size(), 1);

    List<List<NumericBucketPoint>> actualStackedCounterStatsById = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER, asList("C1", "C2"),
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, emptyList(), true));
    assertEquals(actualStackedCounterStatsByTag.size(), 1);

    NumericBucketPoint collectorC1 = createSingleBucket(c1.getDataPoints(), start, start.plusMinutes(5));
    NumericBucketPoint collectorC2 = createSingleBucket(c2.getDataPoints(), start, start.plusMinutes(5));

    final Sum min = new Sum();
    final Sum average = new Sum();
    final Sum median = new Sum();
    final Sum max = new Sum();
    final Sum sum = new Sum();
    Observable.just(collectorC1, collectorC2).forEach(d -> {
        min.increment(d.getMin());
        max.increment(d.getMax());
        average.increment(d.getAvg());
        median.increment(d.getMedian());
        sum.increment(d.getSum());
    });
    NumericBucketPoint expectedStackedRateBucketPoint = new NumericBucketPoint.Builder(start.getMillis(),
            start.plusMinutes(5).getMillis()).setMin(min.getResult()).setMax(max.getResult())
                    .setAvg(average.getResult()).setMedian(median.getResult()).setSum(sum.getResult())
                    .setSamples(2).build();
    List<NumericBucketPoint> expectedStackedCounterStatsList = new ArrayList<NumericBucketPoint>();
    expectedStackedCounterStatsList.add(expectedStackedRateBucketPoint);

    assertNumericBucketsEquals(actualStackedCounterStatsByTag.get(0), expectedStackedCounterStatsList);
    assertNumericBucketsEquals(actualStackedCounterStatsById.get(0), expectedStackedCounterStatsList);

    //Test simple counter rate stats
    List<List<NumericBucketPoint>> actualCounterRateStatsByTag = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER_RATE, tagFilters,
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, emptyList(), false));
    assertEquals(actualCounterRateStatsByTag.size(), 1);

    List<List<NumericBucketPoint>> actualCounterRateStatsById = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER_RATE, asList("C1", "C2"),
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, emptyList(), false));
    assertEquals(actualCounterRateStatsById.size(), 1);

    List<NumericBucketPoint> expectedCounterRateStats = Arrays.asList(
            createSingleBucket(Stream.concat(c1Rate.stream(), c2Rate.stream()).collect(Collectors.toList()),
                    start, start.plusMinutes(5)));

    assertNumericBucketsEquals(actualCounterRateStatsByTag.get(0), expectedCounterRateStats);
    assertNumericBucketsEquals(actualCounterRateStatsById.get(0), expectedCounterRateStats);

    //Test stacked counter rate stats
    List<List<NumericBucketPoint>> actualStackedCounterRateStatsByTag = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER_RATE, tagFilters,
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, emptyList(), true));
    assertEquals(actualStackedCounterStatsByTag.size(), 1);

    List<List<NumericBucketPoint>> actualStackedCounterRateStatsById = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER_RATE, asList("C1", "C2"),
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, emptyList(), true));
    assertEquals(actualStackedCounterStatsByTag.size(), 1);

    NumericBucketPoint collectorC1Rate = createSingleBucket(c1Rate, start, start.plusMinutes(5));
    NumericBucketPoint collectorC2Rate = createSingleBucket(c2Rate, start, start.plusMinutes(5));

    final Sum counterRateMin = new Sum();
    final Sum counterRateMax = new Sum();
    final Sum counterRateAverage = new Sum();
    final Sum counterRateMedian = new Sum();
    final Sum counterRateSum = new Sum();
    Observable.just(collectorC1Rate, collectorC2Rate).forEach(d -> {
        counterRateMin.increment(d.getMin());
        counterRateMax.increment(d.getMax());
        counterRateAverage.increment(d.getAvg());
        counterRateMedian.increment(d.getMedian());
        counterRateSum.increment(d.getSum());
    });
    NumericBucketPoint expectedStackedCounterRateBucketPoint = new NumericBucketPoint.Builder(start.getMillis(),
            start.plusMinutes(5).getMillis()).setMin(counterRateMin.getResult())
                    .setMax(counterRateMax.getResult()).setAvg(counterRateAverage.getResult())
                    .setMedian(counterRateMedian.getResult()).setSum(counterRateSum.getResult()).setSamples(2)
                    .build();
    List<NumericBucketPoint> expectedStackedCounterRateStatsList = new ArrayList<NumericBucketPoint>();
    expectedStackedCounterRateStatsList.add(expectedStackedCounterRateBucketPoint);

    assertNumericBucketsEquals(actualStackedCounterRateStatsByTag.get(0), expectedStackedCounterRateStatsList);
    assertNumericBucketsEquals(actualStackedCounterRateStatsById.get(0), expectedStackedCounterRateStatsList);
}

---

From source file:org.hawkular.metrics.core.service.metrics.GaugeITest.java

@Test
public void findStackedGaugeStatsByMetricNames() {
    NumericDataPointCollector.createPercentile = InMemoryPercentileWrapper::new;

    String tenantId = "findGaugeStatsByMetricNames";
    DateTime start = now().minusMinutes(10);

    Metric<Double> m1 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M1"), getDataPointList("M1", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m1)));

    Metric<Double> m2 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M2"), getDataPointList("M2", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m2)));

    Metric<Double> m3 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M3"), getDataPointList("M3", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m3)));

    Buckets buckets = Buckets.fromCount(start.getMillis(), start.plusMinutes(5).getMillis(), 1);

    List<List<NumericBucketPoint>> actual = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.GAUGE, asList("M1", "M2"),
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, emptyList(), true));

    assertEquals(actual.size(), 1);/*from w ww  .jav  a 2 s.c  o  m*/

    NumericBucketPoint collectorM1 = createSingleBucket(m1.getDataPoints(), start, start.plusMinutes(5));
    NumericBucketPoint collectorM2 = createSingleBucket(m2.getDataPoints(), start, start.plusMinutes(5));

    final Sum min = new Sum();
    final Sum average = new Sum();
    final Sum median = new Sum();
    final Sum max = new Sum();
    Observable.just(collectorM1, collectorM2).forEach(d -> {
        min.increment(d.getMin());
        max.increment(d.getMax());
        average.increment(d.getAvg());
        median.increment(d.getMedian());
    });

    assertEquals(actual.get(0).get(0).getMin(), min.getResult());
    assertEquals(actual.get(0).get(0).getMax(), max.getResult());
    assertEquals(actual.get(0).get(0).getMedian(), median.getResult());
    assertEquals(actual.get(0).get(0).getAvg(), average.getResult());
}

---

From source file:org.hawkular.metrics.core.service.metrics.GaugeITest.java

@Test
public void findStackedGaugeStatsByTags() {
    NumericDataPointCollector.createPercentile = InMemoryPercentileWrapper::new;

    String tenantId = "findGaugeStatsByTags";
    DateTime start = now().minusMinutes(10);

    Metric<Double> m1 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M1"), getDataPointList("M1", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m1)));
    doAction(() -> metricsService.addTags(m1, ImmutableMap.of("type", "cpu_usage", "node", "server1")));

    Metric<Double> m2 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M2"), getDataPointList("M2", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m2)));
    doAction(() -> metricsService.addTags(m2, ImmutableMap.of("type", "cpu_usage", "node", "server2")));

    Metric<Double> m3 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M3"), getDataPointList("M3", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m3)));
    doAction(() -> metricsService.addTags(m3, ImmutableMap.of("type", "cpu_usage", "node", "server3")));

    Buckets buckets = Buckets.fromCount(start.getMillis(), start.plusMinutes(5).getMillis(), 1);
    Map<String, String> tagFilters = ImmutableMap.of("type", "cpu_usage", "node", "server1|server2");

    List<List<NumericBucketPoint>> actual = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.GAUGE, tagFilters, start.getMillis(),
                    start.plusMinutes(5).getMillis(), buckets, emptyList(), true));

    assertEquals(actual.size(), 1);// w w  w  .j av a 2 s .  com

    NumericBucketPoint collectorM1 = createSingleBucket(m1.getDataPoints(), start, start.plusMinutes(5));
    NumericBucketPoint collectorM2 = createSingleBucket(m2.getDataPoints(), start, start.plusMinutes(5));

    final Sum min = new Sum();
    final Sum average = new Sum();
    final Sum median = new Sum();
    final Sum max = new Sum();
    Observable.just(collectorM1, collectorM2).forEach(d -> {
        min.increment(d.getMin());
        max.increment(d.getMax());
        average.increment(d.getAvg());
        median.increment(d.getMedian());
    });

    assertEquals(actual.get(0).get(0).getMin(), min.getResult());
    assertEquals(actual.get(0).get(0).getMax(), max.getResult());
    assertEquals(actual.get(0).get(0).getMedian(), median.getResult());
    assertEquals(actual.get(0).get(0).getAvg(), average.getResult());
}

---

From source file:org.hawkular.metrics.core.service.MetricsServiceITest.java

@Test
public void findSimpleCounterStats() {
    //Setup the counter data
    NumericDataPointCollector.createPercentile = InMemoryPercentileWrapper::new;

    Random r = new Random(123);
    List<Long> randomList = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
        randomList.add((long) r.nextInt(100));
    }/*w  ww.  j  a v a 2  s . c o m*/
    Collections.sort(randomList);
    Iterator<Long> randoms = randomList.iterator();

    String tenantId = "findCounterStats";
    DateTime start = now().minusMinutes(10);

    Metric<Long> c1 = new Metric<>(new MetricId<>(tenantId, COUNTER, "C1"),
            asList(new DataPoint<>(start.getMillis(), 222L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(1).getMillis(), 224L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(2).getMillis(), 226L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(3).getMillis(), 228L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(4).getMillis(), 229L + randoms.next())));
    doAction(() -> metricsService.addDataPoints(COUNTER, Observable.just(c1)));
    doAction(() -> metricsService.addTags(c1, ImmutableMap.of("type", "counter_cpu_usage", "node", "server1")));

    Metric<Long> c2 = new Metric<>(new MetricId<>(tenantId, COUNTER, "C2"),
            asList(new DataPoint<>(start.getMillis(), 150L),
                    new DataPoint<>(start.plusMinutes(1).getMillis(), 153L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(2).getMillis(), 156L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(3).getMillis(), 159L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(4).getMillis(), 162L + randoms.next())));
    doAction(() -> metricsService.addDataPoints(COUNTER, Observable.just(c2)));
    doAction(() -> metricsService.addTags(c2, ImmutableMap.of("type", "counter_cpu_usage", "node", "server2")));

    Metric<Long> c3 = new Metric<>(new MetricId<>(tenantId, COUNTER, "C3"),
            asList(new DataPoint<>(start.getMillis(), 11456L + randoms.next()),
                    new DataPoint<>(start.plusMinutes(1).getMillis(), 183332L + randoms.next())));
    doAction(() -> metricsService.addDataPoints(COUNTER, Observable.just(c3)));
    doAction(() -> metricsService.addTags(c3, ImmutableMap.of("type", "counter_cpu_usage", "node", "server3")));

    Buckets buckets = Buckets.fromCount(start.getMillis(), start.plusMinutes(5).getMillis(), 1);
    Map<String, String> tagFilters = ImmutableMap.of("type", "counter_cpu_usage", "node", "server1|server2");

    List<DataPoint<Double>> c1Rate = getOnNextEvents(() -> metricsService.findRateData(c1.getMetricId(),
            start.getMillis(), start.plusMinutes(5).getMillis()));

    List<DataPoint<Double>> c2Rate = getOnNextEvents(() -> metricsService.findRateData(c2.getMetricId(),
            start.getMillis(), start.plusMinutes(5).getMillis()));

    //Test simple counter stats
    List<List<NumericBucketPoint>> actualCounterStatsByTag = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER, tagFilters, start.getMillis(),
                    start.plusMinutes(5).getMillis(), buckets, Collections.emptyList(), false));
    assertEquals(actualCounterStatsByTag.size(), 1);

    List<List<NumericBucketPoint>> actualCounterStatsById = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER, asList("C1", "C2"),
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, Collections.emptyList(),
                    false));
    assertEquals(actualCounterStatsById.size(), 1);

    List<NumericBucketPoint> expectedCounterStats = Arrays
            .asList(createSingleBucket(Stream.concat(c1.getDataPoints().stream(), c2.getDataPoints().stream())
                    .collect(Collectors.toList()), start, start.plusMinutes(5)));

    assertNumericBucketsEquals(actualCounterStatsByTag.get(0), expectedCounterStats);
    assertNumericBucketsEquals(actualCounterStatsById.get(0), expectedCounterStats);

    //Test stacked counter stats
    List<List<NumericBucketPoint>> actualStackedCounterStatsByTag = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER, tagFilters, start.getMillis(),
                    start.plusMinutes(5).getMillis(), buckets, Collections.emptyList(), true));
    assertEquals(actualStackedCounterStatsByTag.size(), 1);

    List<List<NumericBucketPoint>> actualStackedCounterStatsById = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER, asList("C1", "C2"),
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, Collections.emptyList(),
                    true));
    assertEquals(actualStackedCounterStatsByTag.size(), 1);

    NumericBucketPoint collectorC1 = createSingleBucket(c1.getDataPoints(), start, start.plusMinutes(5));
    NumericBucketPoint collectorC2 = createSingleBucket(c2.getDataPoints(), start, start.plusMinutes(5));

    final Sum min = new Sum();
    final Sum average = new Sum();
    final Sum median = new Sum();
    final Sum max = new Sum();
    Observable.just(collectorC1, collectorC2).forEach(d -> {
        min.increment(d.getMin());
        max.increment(d.getMax());
        average.increment(d.getAvg());
        median.increment(d.getMedian());
    });
    NumericBucketPoint expectedStackedRateBucketPoint = new NumericBucketPoint.Builder(start.getMillis(),
            start.plusMinutes(5).getMillis()).setMin(min.getResult()).setMax(max.getResult())
                    .setAvg(average.getResult()).setMedian(median.getResult()).setSamples(2).build();
    List<NumericBucketPoint> expectedStackedCounterStatsList = new ArrayList<NumericBucketPoint>();
    expectedStackedCounterStatsList.add(expectedStackedRateBucketPoint);

    assertNumericBucketsEquals(actualStackedCounterStatsByTag.get(0), expectedStackedCounterStatsList);
    assertNumericBucketsEquals(actualStackedCounterStatsById.get(0), expectedStackedCounterStatsList);

    //Test simple counter rate stats
    List<List<NumericBucketPoint>> actualCounterRateStatsByTag = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER_RATE, tagFilters,
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, Collections.emptyList(),
                    false));
    assertEquals(actualCounterRateStatsByTag.size(), 1);

    List<List<NumericBucketPoint>> actualCounterRateStatsById = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER_RATE, asList("C1", "C2"),
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, Collections.emptyList(),
                    false));
    assertEquals(actualCounterRateStatsById.size(), 1);

    List<NumericBucketPoint> expectedCounterRateStats = Arrays.asList(
            createSingleBucket(Stream.concat(c1Rate.stream(), c2Rate.stream()).collect(Collectors.toList()),
                    start, start.plusMinutes(5)));

    assertNumericBucketsEquals(actualCounterRateStatsByTag.get(0), expectedCounterRateStats);
    assertNumericBucketsEquals(actualCounterRateStatsById.get(0), expectedCounterRateStats);

    //Test stacked counter rate stats
    List<List<NumericBucketPoint>> actualStackedCounterRateStatsByTag = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER_RATE, tagFilters,
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, Collections.emptyList(),
                    true));
    assertEquals(actualStackedCounterStatsByTag.size(), 1);

    List<List<NumericBucketPoint>> actualStackedCounterRateStatsById = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.COUNTER_RATE, asList("C1", "C2"),
                    start.getMillis(), start.plusMinutes(5).getMillis(), buckets, Collections.emptyList(),
                    true));
    assertEquals(actualStackedCounterStatsByTag.size(), 1);

    NumericBucketPoint collectorC1Rate = createSingleBucket(c1Rate, start, start.plusMinutes(5));
    NumericBucketPoint collectorC2Rate = createSingleBucket(c2Rate, start, start.plusMinutes(5));

    final Sum counterRateMin = new Sum();
    final Sum counterRateMax = new Sum();
    final Sum counterRateAverage = new Sum();
    final Sum counterRateMedian = new Sum();
    Observable.just(collectorC1Rate, collectorC2Rate).forEach(d -> {
        counterRateMin.increment(d.getMin());
        counterRateMax.increment(d.getMax());
        counterRateAverage.increment(d.getAvg());
        counterRateMedian.increment(d.getMedian());
    });
    NumericBucketPoint expectedStackedCounterRateBucketPoint = new NumericBucketPoint.Builder(start.getMillis(),
            start.plusMinutes(5).getMillis()).setMin(counterRateMin.getResult())
                    .setMax(counterRateMax.getResult()).setAvg(counterRateAverage.getResult())
                    .setMedian(counterRateMedian.getResult()).setSamples(2).build();
    List<NumericBucketPoint> expectedStackedCounterRateStatsList = new ArrayList<NumericBucketPoint>();
    expectedStackedCounterRateStatsList.add(expectedStackedCounterRateBucketPoint);

    assertNumericBucketsEquals(actualStackedCounterRateStatsByTag.get(0), expectedStackedCounterRateStatsList);
    assertNumericBucketsEquals(actualStackedCounterRateStatsById.get(0), expectedStackedCounterRateStatsList);
}

---

From source file:org.hawkular.metrics.core.service.MetricsServiceITest.java

private <T extends Number> NumericBucketPoint createSingleBucket(List<? extends DataPoint<T>> combinedData,
        DateTime start, DateTime end) {//w  w w  . java 2 s.c o  m
    T expectedMin = combinedData.stream()
            .min((x, y) -> Double.compare(x.getValue().doubleValue(), y.getValue().doubleValue())).get()
            .getValue();
    T expectedMax = combinedData.stream()
            .max((x, y) -> Double.compare(x.getValue().doubleValue(), y.getValue().doubleValue())).get()
            .getValue();
    PercentileWrapper expectedMedian = NumericDataPointCollector.createPercentile.apply(50.0);
    Mean expectedAverage = new Mean();
    Sum expectedSamples = new Sum();
    combinedData.stream().forEach(arg -> {
        expectedMedian.addValue(arg.getValue().doubleValue());
        expectedAverage.increment(arg.getValue().doubleValue());
        expectedSamples.increment(1);
    });

    return new NumericBucketPoint.Builder(start.getMillis(), end.getMillis()).setMin(expectedMin.doubleValue())
            .setMax(expectedMax.doubleValue()).setAvg(expectedAverage.getResult())
            .setMedian(expectedMedian.getResult())
            .setSamples(new Double(expectedSamples.getResult()).intValue()).build();
}

---

From source file:org.hawkular.metrics.core.service.MetricsServiceITest.java

@Test
public void findStackedGaugeStatsByTags() {
    NumericDataPointCollector.createPercentile = InMemoryPercentileWrapper::new;

    String tenantId = "findGaugeStatsByTags";
    DateTime start = now().minusMinutes(10);

    Metric<Double> m1 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M1"), getDataPointList("M1", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m1)));
    doAction(() -> metricsService.addTags(m1, ImmutableMap.of("type", "cpu_usage", "node", "server1")));

    Metric<Double> m2 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M2"), getDataPointList("M2", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m2)));
    doAction(() -> metricsService.addTags(m2, ImmutableMap.of("type", "cpu_usage", "node", "server2")));

    Metric<Double> m3 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M3"), getDataPointList("M3", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m3)));
    doAction(() -> metricsService.addTags(m3, ImmutableMap.of("type", "cpu_usage", "node", "server3")));

    Buckets buckets = Buckets.fromCount(start.getMillis(), start.plusMinutes(5).getMillis(), 1);
    Map<String, String> tagFilters = ImmutableMap.of("type", "cpu_usage", "node", "server1|server2");

    List<List<NumericBucketPoint>> actual = getOnNextEvents(
            () -> metricsService.findNumericStats(tenantId, MetricType.GAUGE, tagFilters, start.getMillis(),
                    start.plusMinutes(5).getMillis(), buckets, Collections.emptyList(), true));

    assertEquals(actual.size(), 1);/*  w w w  .ja va2s  .com*/

    NumericBucketPoint collectorM1 = createSingleBucket(m1.getDataPoints(), start, start.plusMinutes(5));
    NumericBucketPoint collectorM2 = createSingleBucket(m2.getDataPoints(), start, start.plusMinutes(5));

    final Sum min = new Sum();
    final Sum average = new Sum();
    final Sum median = new Sum();
    final Sum max = new Sum();
    Observable.just(collectorM1, collectorM2).forEach(d -> {
        min.increment(d.getMin());
        max.increment(d.getMax());
        average.increment(d.getAvg());
        median.increment(d.getMedian());
    });

    assertEquals(actual.get(0).get(0).getMin(), min.getResult());
    assertEquals(actual.get(0).get(0).getMax(), max.getResult());
    assertEquals(actual.get(0).get(0).getMedian(), median.getResult());
    assertEquals(actual.get(0).get(0).getAvg(), average.getResult());
}

---

From source file:org.hawkular.metrics.core.service.MetricsServiceITest.java

@Test
public void findStackedGaugeStatsByMetricNames() {
    NumericDataPointCollector.createPercentile = InMemoryPercentileWrapper::new;

    String tenantId = "findGaugeStatsByMetricNames";
    DateTime start = now().minusMinutes(10);

    Metric<Double> m1 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M1"), getDataPointList("M1", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m1)));

    Metric<Double> m2 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M2"), getDataPointList("M2", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m2)));

    Metric<Double> m3 = new Metric<>(new MetricId<>(tenantId, GAUGE, "M3"), getDataPointList("M3", start));
    doAction(() -> metricsService.addDataPoints(GAUGE, Observable.just(m3)));

    Buckets buckets = Buckets.fromCount(start.getMillis(), start.plusMinutes(5).getMillis(), 1);

    List<List<NumericBucketPoint>> actual = getOnNextEvents(() -> metricsService.findNumericStats(tenantId,
            MetricType.GAUGE, asList("M1", "M2"), start.getMillis(), start.plusMinutes(5).getMillis(), buckets,
            Collections.emptyList(), true));

    assertEquals(actual.size(), 1);/* ww  w  . java2 s .  c  o  m*/

    NumericBucketPoint collectorM1 = createSingleBucket(m1.getDataPoints(), start, start.plusMinutes(5));
    NumericBucketPoint collectorM2 = createSingleBucket(m2.getDataPoints(), start, start.plusMinutes(5));

    final Sum min = new Sum();
    final Sum average = new Sum();
    final Sum median = new Sum();
    final Sum max = new Sum();
    Observable.just(collectorM1, collectorM2).forEach(d -> {
        min.increment(d.getMin());
        max.increment(d.getMax());
        average.increment(d.getAvg());
        median.increment(d.getMedian());
    });

    assertEquals(actual.get(0).get(0).getMin(), min.getResult());
    assertEquals(actual.get(0).get(0).getMax(), max.getResult());
    assertEquals(actual.get(0).get(0).getMedian(), median.getResult());
    assertEquals(actual.get(0).get(0).getAvg(), average.getResult());
}

---