@Test public void requestTrackingDisabledIfNotNamedFuseable() { Flux<Integer> source = Flux.range(1, 10); new FluxMetricsFuseable<>(source, registry) .blockLast(); DistributionSummary meter = registry.find(METER_REQUESTED) .summary(); if (meter != null) { //meter could be null in some tests assertThat(meter.count()).isZero(); } }
@Test public void requestTrackingFuseable() { BaseSubscriber<Integer> bs = new BaseSubscriber<Integer>() { @Override protected void hookOnSubscribe(Subscription subscription) { subscription.request(1); } }; Flux<Integer> source = Flux.range(1, 10) .name("foo"); new FluxMetricsFuseable<>(source, registry) .subscribe(bs); DistributionSummary meter = registry.find(METER_REQUESTED) .tag(TAG_SEQUENCE_NAME, "foo") .summary(); assertThat(meter).as("meter").isNotNull(); assertThat(meter.totalAmount()).isEqualTo(1); bs.request(7); assertThat(meter.totalAmount()).isEqualTo(8); assertThat(meter.max()).isEqualTo(7); bs.request(100); assertThat(meter.totalAmount()).isEqualTo(108); assertThat(meter.max()).isEqualTo(100); } }
public void micrometerHistogram(MicrometerState state, Data data) { state.summary.record(data.dataIterator.next()); }
Optional<String> writeSummary(DistributionSummary summary) { summary.takeSnapshot(); return Optional.of(writeDocument(summary, builder -> { builder.append(",\"count\":").append(summary.count()); builder.append(",\"sum\":").append(summary.totalAmount()); builder.append(",\"mean\":").append(summary.mean()); builder.append(",\"max\":").append(summary.max()); })); }
@Test @DisplayName("negative quantities are ignored") default void recordNegative(MeterRegistry registry) { DistributionSummary ds = registry.summary("my.summary"); ds.record(-10); assertAll(() -> assertEquals(0, ds.count()), () -> assertEquals(0L, ds.totalAmount())); }
@Nullable private Optional<String> writeSummary(DistributionSummary summary) { HistogramSnapshot snapshot = summary.takeSnapshot(); if (snapshot.count() > 0) { return Optional.of(write(summary.getId(), "distributionSummary", Fields.Count.tag(), decimal(summary.count()), Fields.Sum.tag(), decimal(summary.totalAmount()), Fields.Max.tag(), decimal(summary.max()))); } return Optional.empty(); }
@Test @DisplayName("scale samples by a fixed factor") default void scale(MeterRegistry registry) { DistributionSummary ds = DistributionSummary.builder("my.summary") .scale(2.0) .register(registry); ds.record(1); clock(registry).add(step()); assertThat(ds.totalAmount()).isEqualTo(2.0); }
@Deprecated @Test default void histogramCounts(MeterRegistry registry) { DistributionSummary s = DistributionSummary.builder("my.summmary") .sla(1) .register(registry); s.record(1); assertThat(s.histogramCountAtValue(1)).isEqualTo(1); assertThat(s.histogramCountAtValue(2)).isEqualTo(Double.NaN); } }
@Deprecated @Test default void percentiles(MeterRegistry registry) { DistributionSummary s = DistributionSummary.builder("my.summary") .publishPercentiles(1) .register(registry); s.record(1); assertThat(s.percentile(1)).isEqualTo(1, Offset.offset(0.3)); assertThat(s.percentile(0.5)).isEqualTo(Double.NaN); }
@Override protected void doProcess(Exchange exchange, MicrometerEndpoint endpoint, DistributionSummary summary) { Double value = simple(exchange, endpoint.getValue(), Double.class); Double finalValue = getDoubleHeader(exchange.getIn(), HEADER_HISTOGRAM_VALUE, value); if (finalValue != null) { summary.record(finalValue); } else { LOG.warn("Cannot update histogram \"{}\" with null value", summary.getId().getName()); } } }
public void markSuccessMetrics(String roadName, long avroBytes) { Iterable<Tag> tags = singleton(Tag.of(ROAD, roadName)); registry.counter("onramp.send-success", tags).increment(); DistributionSummary .builder("onramp.message-size") .tags(tags) .publishPercentileHistogram() .register(registry) .record(avroBytes); }
/** * Returns a newly-registered {@link DistributionSummary} with percentile publication configured. * @deprecated Use {@link #newDistributionSummary(MeterRegistry, String, Iterable)}. */ @Deprecated public static DistributionSummary summaryWithDefaultQuantiles(MeterRegistry registry, String name, Iterable<Tag> tags) { requireNonNull(registry, "registry"); requireNonNull(name, "name"); requireNonNull(tags, "tags"); return DistributionSummary.builder(name) .tags(tags) .publishPercentiles(PERCENTILES) .register(registry); }
private Metric<Number> toSummaryMetric(DistributionSummary summary) { return new Metric<Number>(summary.getId(), summary.takeSnapshot()); }
@Override public long totalAmount() { return (long) impl.totalAmount(); }
@TearDown(Level.Iteration) public void tearDown(Blackhole hole) { hole.consume(summary.takeSnapshot().count()); } }
@Override public double max() { return summary.max(); }
@Override public double mean() { return summary.mean(); }
private Stream<SignalFxProtocolBuffers.DataPoint.Builder> addDistributionSummary(DistributionSummary summary) { return Stream.of( addDatapoint(summary, COUNTER, "count", summary.count()), addDatapoint(summary, COUNTER, "totalTime", summary.totalAmount()), addDatapoint(summary, GAUGE, "avg", summary.mean()), addDatapoint(summary, GAUGE, "max", summary.max()) ); }
@Test @DisplayName("multiple recordings are maintained") default void record(MeterRegistry registry) { DistributionSummary ds = registry.summary("my.summary"); ds.record(10); clock(registry).add(step()); ds.count(); assertAll(() -> assertEquals(1L, ds.count()), () -> assertEquals(10L, ds.totalAmount())); ds.record(10); ds.record(10); clock(registry).add(step()); assertAll(() -> assertTrue(ds.count() >= 2L), () -> assertTrue(ds.totalAmount() >= 20L)); }
@Setup(Level.Iteration) public void setup() { registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT, new CollectorRegistry(), Clock.SYSTEM); summary = DistributionSummary.builder("summary") .publishPercentileHistogram() .register(registry); }