/** * 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); }
/** * Returns a newly-registered {@link Timer} configured by {@link #distributionStatisticConfig()}. */ public static Timer newTimer(MeterRegistry registry, String name, Iterable<Tag> tags) { requireNonNull(registry, "registry"); requireNonNull(name, "name"); requireNonNull(tags, "tags"); final Duration maxExpectedValue = Optional.ofNullable(distStatCfg.getMaximumExpectedValue()) .map(Duration::ofNanos).orElse(null); final Duration minExpectedValue = Optional.ofNullable(distStatCfg.getMinimumExpectedValue()) .map(Duration::ofNanos).orElse(null); return Timer.builder(name) .tags(tags) .maximumExpectedValue(maxExpectedValue) .minimumExpectedValue(minExpectedValue) .publishPercentiles(distStatCfg.getPercentiles()) .publishPercentileHistogram(distStatCfg.isPercentileHistogram()) .distributionStatisticBufferLength(distStatCfg.getBufferLength()) .distributionStatisticExpiry(distStatCfg.getExpiry()) .register(registry); }
.tag(FluxMetrics.TAG_EXCEPTION, "") .description("Times the duration elapsed between a subscription and the onComplete termination of the sequence") .register(registry); this.subscribeToCancelTimer = Timer .builder(FluxMetrics.METER_FLOW_DURATION) .tag(FluxMetrics.TAG_EXCEPTION, "") .description("Times the duration elapsed between a subscription and the cancellation of the sequence") .register(registry); return subscribeToErrorTimerBuilder .tag(FluxMetrics.TAG_EXCEPTION, e.getClass().getName()) .register(registry); };
public MicrometerTimer(MeterRegistry meterRegistry, MetricId id) { super(id); timer = io.micrometer.core.instrument.Timer.builder(id.getName()) .description(id.getDescription()) .tags(id.getTags().stream().map(tag -> Tag.of(tag.getKey(), tag.getValue())) .collect(Collectors.toList())) .publishPercentiles(0.5, 0.75, 0.98, 0.99, 0.999) .register(meterRegistry); }
@Override public void action(StateMachine<S, E> stateMachine, Action<S, E> action, long duration) { String actionName = actionToName(action); getActionCounterBuilder(action).register(meterRegistry).increment(); getActionTimerBuilder(action).register(meterRegistry).record(duration, TimeUnit.MILLISECONDS); Map<String, Object> traceInfo = new HashMap<>(); traceInfo.put("action", actionName); traceInfo.put("duration", duration); traceInfo.put("machine", stateMachine.getId()); traceRepository.add(traceInfo); }
public Timer get(String... values) { // Get or create the Timer return Timer.builder(name) .description(description) .tags(Labels.toTags(keys, values)) .register(registry); }
@Override public void transition(StateMachine<S, E> stateMachine, Transition<S, E> transition, long duration) { getTransitionCounterBuilder(transition).register(meterRegistry).increment(); getTransitionTimerBuilder(transition).register(meterRegistry).record(duration, TimeUnit.MILLISECONDS); Map<String, Object> traceInfo = new HashMap<>(); traceInfo.put("transition", transitionToName(transition)); traceInfo.put("duration", duration); traceInfo.put("machine", stateMachine.getId()); traceRepository.add(traceInfo); }
public void onExchangeDone(Exchange exchange) { Timer.Sample sample = (Timer.Sample) exchange.removeProperty(propertyName(exchange)); if (sample != null) { Timer timer = Timer.builder(namingStrategy.getName(route)) .tags(namingStrategy.getTags(route, exchange)) .description(route.getDescription()) .register(meterRegistry); sample.stop(timer); } }
@Test @DisplayName("meters with synthetics can be removed without causing deadlocks") void removeMeterWithSynthetic(MeterRegistry registry) { Timer timer = Timer.builder("my.timer") .publishPercentiles(0.95) .sla(Duration.ofMillis(10)) .register(registry); registry.remove(timer); }
@Deprecated @Test default void percentiles(MeterRegistry registry) { Timer t = Timer.builder("my.timer") .publishPercentiles(1) .register(registry); t.record(1, TimeUnit.MILLISECONDS); assertThat(t.percentile(1, TimeUnit.MILLISECONDS)).isEqualTo(1, Offset.offset(0.3)); assertThat(t.percentile(0.5, TimeUnit.MILLISECONDS)).isEqualTo(Double.NaN); }
@Override public void onSuccess(final ClientHttpResponse response) { getTimeBuilder(urlTemplate, request, response).register(meterRegistry) .record(clock.monotonicTime() - startTime, TimeUnit.NANOSECONDS); }
@Override public void onFailure(final Throwable ex) { getTimeBuilder(urlTemplate, request, null).register(meterRegistry) .record(clock.monotonicTime() - startTime, TimeUnit.NANOSECONDS); } });
@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())); }
/** * Creates a new timer function using the given template. This method initializes the default timers. * * @param timerTemplate The template to create the instances from. * @return The newly created function that returns a timer for a given code. */ protected Function<Code, Timer> asTimerFunction(final Supplier<Timer.Builder> timerTemplate) { final Map<Code, Timer> cache = new EnumMap<>(Code.class); final Function<Code, Timer> creator = code -> timerTemplate.get() .tag(TAG_STATUS_CODE, code.name()) .register(this.registry); final Function<Code, Timer> cacheResolver = code -> cache.computeIfAbsent(code, creator); // Eager initialize for (final Code code : this.eagerInitializedCodes) { cacheResolver.apply(code); } return cacheResolver; }
@Override public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException { long startTime = System.nanoTime(); ClientHttpResponse response = null; try { response = execution.execute(request, body); return response; } finally { getTimeBuilder(request, response).register(this.meterRegistry) .record(System.nanoTime() - startTime, TimeUnit.NANOSECONDS); urlTemplate.remove(); } }
private void stop(Timer.Sample timerSample, Supplier<Iterable<Tag>> tags, Builder builder) { timerSample.stop(builder.tags(tags.get()).register(this.registry)); }
@Override public MicroTimer build() { return new MicroTimer(this.builder.register(this.meterRegistry), this.meterRegistry); }
.tag(TAG_EXCEPTION, "") .description("Times the duration elapsed between a subscription and the onComplete termination of the sequence") .register(registry); this.subscribeToCancelTimer = Timer .builder(METER_FLOW_DURATION) .tag(TAG_EXCEPTION, "") .description("Times the duration elapsed between a subscription and the cancellation of the sequence") .register(registry); return subscribeToErrorTimerBuilder .tag(TAG_EXCEPTION, e.getClass().getName()) .register(registry); }; .tags(commonTags) .description("Measures delays between onNext signals (or between onSubscribe and first onNext)") .register(registry);
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); }