/** {@inheritDoc} */ @Override public void recordConnectionAcquiredNanos(final long elapsedAcquiredNanos) { connectionObtainTimer.record(elapsedAcquiredNanos, TimeUnit.NANOSECONDS); }
/** * Returns a newly-registered {@link Timer} with percentile publication configured. * @deprecated Use {@link #newTimer(MeterRegistry, String, Iterable)}. */ @Deprecated public static Timer timerWithDefaultQuantiles(MeterRegistry registry, String name, Iterable<Tag> tags) { requireNonNull(registry, "registry"); requireNonNull(name, "name"); requireNonNull(tags, "tags"); return Timer.builder(name) .tags(tags) .publishPercentiles(PERCENTILES) .register(registry); }
@Benchmark public int sumTimedWithSample() { Timer.Sample sample = Timer.start(registry); int sum = sum(); sample.stop(timer); return sum; }
public Sample start(MeterRegistry registry) { if (longTask) { LongTaskTimer.Sample sample = LongTaskTimer.builder(name) .description(description) .tags(tags) .register(registry) .start(); return () -> sample.stop(); } Timer.Sample sample = Timer.start(registry); Timer timer = Timer.builder(name) .description(description) .tags(tags) .publishPercentileHistogram(histogram) .publishPercentiles(percentiles) .register(registry); return () -> sample.stop(timer); }
@Test @DisplayName("negative times are discarded by the Timer") default void recordNegative(MeterRegistry registry) { Timer t = registry.timer("myTimer"); t.record(-42, TimeUnit.MILLISECONDS); assertAll(() -> assertEquals(0L, t.count()), () -> assertEquals(0, t.totalTime(TimeUnit.NANOSECONDS), 1.0e-12)); }
private long getCount(String tagKey, String tagValue) { return this.meterRegistry.get(REQUEST_METRICS_NAME).tag(tagKey, tagValue) .timer().count(); }
@Override public Mono<ClientResponse> filter(ClientRequest clientRequest, ExchangeFunction exchangeFunction) { return exchangeFunction.exchange(clientRequest).doOnEach((signal) -> { if (!signal.isOnComplete()) { Long startTime = signal.getContext().get(METRICS_WEBCLIENT_START_TIME); ClientResponse clientResponse = signal.get(); Throwable throwable = signal.getThrowable(); Iterable<Tag> tags = this.tagProvider.tags(clientRequest, clientResponse, throwable); Timer.builder(this.metricName).tags(tags) .description("Timer of WebClient operation") .register(this.meterRegistry) .record(System.nanoTime() - startTime, TimeUnit.NANOSECONDS); } }).subscriberContext((context) -> context.put(METRICS_WEBCLIENT_START_TIME, System.nanoTime())); }
@Deprecated @Test default void histogramCounts(MeterRegistry registry) { Timer t = Timer.builder("my.timer") .sla(Duration.ofMillis(1)) .register(registry); t.record(1, TimeUnit.MILLISECONDS); assertThat(t.histogramCountAtValue((long) millisToUnit(1, TimeUnit.NANOSECONDS))).isEqualTo(1); assertThat(t.histogramCountAtValue(1)).isEqualTo(Double.NaN); } }
@Test @DisplayName("record with stateful Sample instance") default void recordWithSample(MeterRegistry registry) { Timer timer = registry.timer("myTimer"); Timer.Sample sample = Timer.start(registry); clock(registry).add(10, TimeUnit.NANOSECONDS); sample.stop(timer); clock(registry).add(step()); assertAll(() -> assertEquals(1L, timer.count()), () -> assertEquals(10, timer.totalTime(TimeUnit.NANOSECONDS), 1.0e-12)); }
@Test public void queuePollTracksOnNext() { //prepare registry with mock clock MockClock clock = new MockClock(); removeRegistry(); registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock); Metrics.globalRegistry.add(registry); AssertSubscriber<Integer> testSubscriber = AssertSubscriber.create(); MicrometerFluxMetricsFuseableSubscriber<Integer> fuseableSubscriber = new MicrometerFluxMetricsFuseableSubscriber<>(testSubscriber, registry, clock, "foo", Collections.emptyList()); Fuseable.QueueSubscription<Integer> testQueue = new FluxPeekFuseableTest.AssertQueueSubscription<>(); testQueue.offer(1); fuseableSubscriber.onSubscribe(testQueue); clock.add(Duration.ofMillis(200)); Integer val1 = fuseableSubscriber.poll(); Integer val2 = fuseableSubscriber.poll(); assertThat(val1).isEqualTo(1); assertThat(val2).isNull(); //test meters Timer nextTimer = registry.find(METER_ON_NEXT_DELAY) .timer(); assertThat(nextTimer).isNotNull(); assertThat(nextTimer.max(TimeUnit.MILLISECONDS)).as("onNext max delay").isEqualTo(200); }
this.meterRegistry.find(METRIC_NAME_CLIENT_PROCESSING_DURATION).timer(); assertNotNull(clientTimer); assertEquals(1, clientTimer.count()); assertTrue(clientTimer.max(TimeUnit.SECONDS) < 1); .timer(); assertNotNull(serverTimer); assertEquals(1, serverTimer.count()); assertTrue(serverTimer.max(TimeUnit.SECONDS) < 1); assertTrue(serverTimer.max(TimeUnit.SECONDS) <= clientTimer.max(TimeUnit.SECONDS)); assertEquals(2, clientTimer.count()); assertTrue(clientTimer.max(TimeUnit.SECONDS) < 1); assertEquals(2, serverTimer.count()); assertTrue(serverTimer.max(TimeUnit.SECONDS) < 1); assertTrue(serverTimer.max(TimeUnit.SECONDS) <= clientTimer.max(TimeUnit.SECONDS)); log.info("--- Test completed ---");
private Map<String, Map> httpRequestsMetrics() { Set<String> statusCode = new HashSet<>(); Collection<Timer> timers = this.meterRegistry.find("http.server.requests").timers(); timers.forEach(timer -> statusCode.add(timer.getId().getTag("status"))); Map<String, Map> resultsHttp = new HashMap<>(); Map<String, Map<String, Number>> resultsHttpPerCode = new HashMap<>(); statusCode.forEach(code -> { Map<String, Number> resultsPerCode = new HashMap<>(); Collection<Timer> httpTimersStream = this.meterRegistry.find("http.server.requests").tag("status", code).timers(); long count = httpTimersStream.stream().map(Timer::count).reduce((x, y) -> x + y).orElse(0L); double max = httpTimersStream.stream().map(x -> x.max(TimeUnit.MILLISECONDS)).reduce((x, y) -> x > y ? x : y).orElse((double) 0); double totalTime = httpTimersStream.stream().map(x -> x.totalTime(TimeUnit.MILLISECONDS)).reduce((x, y) -> (x + y)).orElse((double) 0); resultsPerCode.put("count", count); resultsPerCode.put("max", max); resultsPerCode.put("mean", count != 0 ? totalTime / count : 0); resultsHttpPerCode.put(code, resultsPerCode); }); resultsHttp.put("percode", resultsHttpPerCode); timers = this.meterRegistry.find("http.server.requests").timers(); long countAllrequests = timers.stream().map(Timer::count).reduce((x, y) -> x + y).orElse(0L); Map<String, Number> resultsHTTPAll = new HashMap<>(); resultsHTTPAll.put("count", countAllrequests); resultsHttp.put("all", resultsHTTPAll); return resultsHttp; }
@Override public String format(Collection<Gauge> gauges, Collection<Timer> timers) { StringBuilder builder = new StringBuilder("\n########## Metrics Start ##########\n"); gauges.stream().forEach(gauge -> { builder.append("Gauge [" + gauge.getId() + "]: "); builder.append(gauge.value() + "\n"); }); timers.stream().forEach(timer -> { builder.append("Timer [" + timer.getId() + "]: "); builder.append( "totalTime=" + timer.totalTime(timer.baseTimeUnit()) + " " + timer.baseTimeUnit() + "\n"); }); builder.append("########## Metrics End ############"); return builder.toString(); }
private Metric<Number> toTimerMetric(Timer timer) { return new Metric<Number>(timer.getId(), timer.takeSnapshot()); }
private void assertMetricsContainsTag(String tagKey, String tagValue) { List<Meter.Id> meterIds = null; try { meterIds = this.meterRegistry.getMeters().stream() .map(Meter::getId) .collect(Collectors.toList()); Collection<Timer> timers = this.meterRegistry.get(REQUEST_METRICS_NAME).timers(); System.err.println("Looking for gateway.requests: tag: " + tagKey + ", value: "+ tagValue); timers.forEach(timer -> System.err.println(timer.getId()+timer.getClass().getSimpleName())); long count = getCount(tagKey, tagValue); assertThat(count).isEqualTo(1); } catch (MeterNotFoundException e) { System.err.println("\n\n\nError finding gatway.requests meter: tag: " + tagKey + ", value: "+ tagValue); System.err.println("\n\n\nMeter ids prior to search: "+meterIds + "\n\n\n and after:"); this.meterRegistry.forEachMeter(meter -> System.err.println(meter.getId() + meter.getClass().getSimpleName())); // try again? long count = getCount(tagKey, tagValue); if (count != 1) { throw e; } } }
@Override public double mean(TimeUnit unit) { return timer.mean(unit); }
Optional<String> writeTimer(Timer timer) { return Optional.of(writeDocument(timer, builder -> { builder.append(",\"count\":").append(timer.count()); builder.append(",\"sum\":").append(timer.totalTime(getBaseTimeUnit())); builder.append(",\"mean\":").append(timer.mean(getBaseTimeUnit())); builder.append(",\"max\":").append(timer.max(getBaseTimeUnit())); })); }
@Test @DisplayName("record durations") default void recordDuration(MeterRegistry registry) { Timer t = registry.timer("myTimer"); t.record(Duration.ofMillis(42)); clock(registry).add(step()); assertAll(() -> assertEquals(1L, t.count()), () -> assertEquals(42, t.totalTime(TimeUnit.MILLISECONDS), 1.0e-12)); }
@Test public void onNextTimerCountsFuseable() { Flux<Integer> source = Flux.range(1, 123); new FluxMetricsFuseable<>(source, registry) .blockLast(); Timer nextMeter = registry .find(METER_ON_NEXT_DELAY) .timer(); assertThat(nextMeter).isNotNull(); assertThat(nextMeter.count()).isEqualTo(123L); Flux<Integer> source2 = Flux.range(1, 10); new FluxMetricsFuseable<>(source2, registry) .take(3) .blockLast(); assertThat(nextMeter.count()).isEqualTo(126L); Flux<Integer> source3 = Flux.range(1, 1000) .name("foo"); new FluxMetricsFuseable<>(source3, registry) .blockLast(); assertThat(nextMeter.count()) .as("notTakingNamedIntoAccount") .isEqualTo(126L); }