Java Code Examples for io.micrometer.core.instrument.Timer#Sample

@Override
public Mono<Payload> requestResponse(Payload payload) {
	AtomicReference<Timer.Sample> timer = new AtomicReference<>();
	GatewayExchange exchange = createExchange(REQUEST_RESPONSE, payload);
	return findRSocketOrCreatePending(exchange).flatMap(rSockets -> {
		retain(payload, rSockets);
		List<Mono<Payload>> results = rSockets.stream()
				.map(rSocket -> rSocket.requestResponse(payload))
				.collect(Collectors.toList());

		return Flux.merge(results).next();
		// TODO: does this cancel the others?
	}).doOnSubscribe(s -> timer.set(Timer.start(meterRegistry)))
			.doOnError(t -> count(exchange, "error"))
			.doFinally(s -> timer.get().stop(meterRegistry
					.timer(getMetricName(exchange), exchange.getTags())));
}
 

private Object timedProceed(ProceedingJoinPoint pjp, Timed timed) throws Throwable {
  if (timed.value().isEmpty()) {
    return pjp.proceed();
  }
  Timer.Sample sample = Timer.start(registry);
  try {
    return pjp.proceed();
  } finally {
    sample.stop(
        Timer.builder(timed.value())
            .description(timed.description().isEmpty() ? null : timed.description())
            .tags(timed.extraTags())
            .tags(tagsBasedOnJoinpoint.apply(pjp))
            .publishPercentileHistogram(timed.histogram())
            .publishPercentiles(timed.percentiles().length == 0 ? null : timed.percentiles())
            .register(registry));
  }
}
 

/**
 * Log the reconciliation outcome.
 */
private void handleResult(Reconciliation reconciliation, AsyncResult<Void> result, Timer.Sample reconciliationTimerSample) {
    if (result.succeeded()) {
        successfulReconciliationsCounter.increment();
        reconciliationTimerSample.stop(reconciliationsTimer);
        log.info("{}: reconciled", reconciliation);
    } else {
        Throwable cause = result.cause();
        if (cause instanceof InvalidConfigParameterException) {
            failedReconciliationsCounter.increment();
            reconciliationTimerSample.stop(reconciliationsTimer);
            log.warn("{}: Failed to reconcile {}", reconciliation, cause.getMessage());
        } else if (cause instanceof UnableToAcquireLockException) {
            lockedReconciliationsCounter.increment();
        } else  {
            failedReconciliationsCounter.increment();
            reconciliationTimerSample.stop(reconciliationsTimer);
            log.warn("{}: Failed to reconcile", reconciliation, cause);
        }
    }
}
 

Future<Void> reconcileConnectorAndHandleResult(Reconciliation reconciliation, String host, KafkaConnectApi apiClient,
                                         boolean useResources, String connectorName, KafkaConnector connector) {
    Promise<Void> reconciliationResult = Promise.promise();

    connectorsReconciliationsCounter.increment();
    Timer.Sample connectorsReconciliationsTimerSample = Timer.start(metrics.meterRegistry());

    reconcileConnector(reconciliation, host, apiClient, useResources, connectorName, connector)
            .onComplete(result -> {
                connectorsReconciliationsTimerSample.stop(connectorsReconciliationsTimer);

                if (result.succeeded())    {
                    connectorsSuccessfulReconciliationsCounter.increment();
                    reconciliationResult.complete();
                } else {
                    connectorsFailedReconciliationsCounter.increment();
                    reconciliationResult.fail(result.cause());
                }
            });

    return reconciliationResult.future();
}
 

@Override
public void onEvent(RequestEvent event) {
    ContainerRequest containerRequest = event.getContainerRequest();
    Set<Timed> timedAnnotations;

    switch (event.getType()) {
        case ON_EXCEPTION:
            if (!(event.getException() instanceof NotFoundException)) {
                break;
            }
        case REQUEST_MATCHED:
            timedAnnotations = annotations(event);

            timedAnnotationsOnRequest.put(containerRequest, timedAnnotations);
            shortTaskSample.put(containerRequest, Timer.start(registry));

            List<LongTaskTimer.Sample> longTaskSamples = longTaskTimers(timedAnnotations, event).stream().map(LongTaskTimer::start).collect(Collectors.toList());
            if (!longTaskSamples.isEmpty()) {
                this.longTaskSamples.put(containerRequest, longTaskSamples);
            }
            break;
        case FINISHED:
            timedAnnotations = timedAnnotationsOnRequest.remove(containerRequest);
            Timer.Sample shortSample = shortTaskSample.remove(containerRequest);

            if (shortSample != null) {
                for (Timer timer : shortTimers(timedAnnotations, event)) {
                    shortSample.stop(timer);
                }
            }

            Collection<LongTaskTimer.Sample> longSamples = this.longTaskSamples.remove(containerRequest);
            if (longSamples != null) {
                for (LongTaskTimer.Sample longSample : longSamples) {
                    longSample.stop();
                }
            }
            break;
    }
}
 

@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));
}
 

@Benchmark
public int sumTimedWithSample() {
    Timer.Sample sample = Timer.start(registry);
    int sum = sum();
    sample.stop(timer);
    return sum;
}
 

@Override
public V call() throws Exception {
    idleSample.stop(idleTimer);
    Timer.Sample executionSample = Timer.start(registry);
    try {
        return callable.call();
    } finally {
        executionSample.stop(executionTimer);
    }
}
 

@Override
public void run() {
    idleSample.stop(idleTimer);
    Timer.Sample executionSample = Timer.start(registry);
    try {
        command.run();
    } finally {
        executionSample.stop(executionTimer);
    }
}
 

@Override
public void onOpened(Connection connection) {
    Timer.Sample started = Timer.start(registry);
    synchronized (connectionSamplesLock) {
        connectionSamples.put(connection, started);
        maxConnections.record(connectionSamples.size());
    }
}
 

private void stopTimerIfStillRunning(ExecuteContext ctx) {
    Iterable<Tag> queryTags = queryTagsSupplier.get();
    if (queryTags == null) return;

    Timer.Sample sample;
    synchronized (sampleLock) {
        sample = sampleByExecuteContext.remove(ctx);
    }
    if (sample == null) return;

    String exceptionName = "none";
    String exceptionSubclass = "none";

    Exception exception = ctx.exception();
    if (exception != null) {
        if (exception instanceof DataAccessException) {
            DataAccessException dae = (DataAccessException) exception;
            exceptionName = dae.sqlStateClass().name().toLowerCase().replace('_', ' ');
            exceptionSubclass = dae.sqlStateSubclass().name().toLowerCase().replace('_', ' ');
            if (exceptionSubclass.contains("no subclass")) {
                exceptionSubclass = "none";
            }
        } else {
            String simpleName = exception.getClass().getSimpleName();
            exceptionName = StringUtils.isNotBlank(simpleName) ? simpleName : exception.getClass().getName();
        }
    }

    //noinspection unchecked
    sample.stop(Timer.builder("jooq.query")
            .description("Execution time of a SQL query performed with JOOQ")
            .tags(queryTags)
            .tag("type", ctx.type().name().toLowerCase())
            .tag("exception", exceptionName)
            .tag("exception.subclass", exceptionSubclass)
            .tags(tags)
            .register(registry));
}
 

@Around("execution (@io.micrometer.core.annotation.Timed * *.*(..))")
public Object timedMethod(ProceedingJoinPoint joinPoint) throws Throwable {

  MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();

  String className = methodSignature.getDeclaringType().getSimpleName();
  String methodName = methodSignature.getName();
  String metricName = String.format("%s.%s", className, methodName);

  Timer.Sample timer = Timer.start(registry);

  //@formatter:off
  return Try.of(joinPoint::proceed)
            .map(value ->
                Match(value).of(
                    Case($(instanceOf(Mono.class)),
                        m -> m.doOnTerminate(() -> stopTimer(className, methodName, metricName, timer))),

                    Case($(instanceOf(Flux.class)),
                        f -> f.doOnTerminate(() -> stopTimer(className, methodName, metricName, timer))),

                    Case($(), res -> {
                      stopTimer(className, methodName, metricName, timer);
                      return res;
                    })
                ))
            .get();
  //@formatter:on
}
 

@Around("execution (@io.micrometer.core.annotation.Timed * *.*(..))")
public Object timedMethod(ProceedingJoinPoint joinPoint) throws Throwable {

  MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();

  String className = methodSignature.getDeclaringType().getSimpleName();
  String methodName = methodSignature.getName();
  String metricName = String.format("%s.%s", className, methodName);

  Timer.Sample timer = Timer.start(registry);

  //@formatter:off
  return Try.of(joinPoint::proceed)
            .map(value ->
                Match(value).of(
                    Case($(instanceOf(Mono.class)),
                        m -> m.doOnTerminate(() -> stopTimer(className, methodName, metricName, timer))),

                    Case($(instanceOf(Flux.class)),
                        f -> f.doOnTerminate(() -> stopTimer(className, methodName, metricName, timer))),

                    Case($(), res -> {
                      stopTimer(className, methodName, metricName, timer);
                      return res;
                    })
                ))
            .get();
  //@formatter:on
}
 

static void recordOnError(Tags commonTags, MeterRegistry registry, Timer.Sample flowDuration, Throwable e) {
	Timer timer = Timer.builder(METER_FLOW_DURATION)
	                   .tags(commonTags.and(TAG_ON_ERROR))
	                   .tag(TAG_KEY_EXCEPTION,
			                   e.getClass()
			                    .getName())
	                   .description(
			                   "Times the duration elapsed between a subscription and the onError termination of the sequence, with the exception name as a tag.")
	                   .register(registry);

	flowDuration.stop(timer);
}
 

protected Object profileMethod(ProceedingJoinPoint pjp) throws Throwable {
	Timer.Sample sample = Timer.start(meterRegistry);
	try {
		return pjp.proceed();
	} finally {
		sample.stop(meterRegistry.timer(MetricsListener.METRIC_NAME, Arrays.asList(//
				new ImmutableTag("context", getStepIdentifier()), //
				new ImmutableTag("method", ClassUtils.getShortName(pjp.getTarget().getClass()) + "."
						+ pjp.getSignature().getName()))));
	}
}
 

private void startTimer(ExecuteContext ctx) {
    Timer.Sample started = Timer.start(registry);
    synchronized (sampleLock) {
        sampleByExecuteContext.put(ctx, started);
    }
}
 

private void stopTimer(String className, String methodName, String metricName, Timer.Sample timer) {
  long elapsedTime = timer.stop(getTimer(className, methodName, metricName));
  long elapsedTimeInSeconds = TimeUnit.MILLISECONDS.convert(elapsedTime, TimeUnit.NANOSECONDS);

  LOGGER.debug("Execution of method : {} took : {} milliseconds", metricName, elapsedTimeInSeconds);
}
 

/**
 * Reconcile assembly resources in the given namespace having the given {@code name}.
 * Reconciliation works by getting the assembly resource (e.g. {@code KafkaUser})
 * in the given namespace with the given name and
 * comparing with the corresponding resource.
 * @param reconciliation The reconciliation.
 * @return A Future which is completed with the result of the reconciliation.
 */
@Override
public final Future<Void> reconcile(Reconciliation reconciliation) {
    String namespace = reconciliation.namespace();
    String name = reconciliation.name();

    reconciliationsCounter.increment();
    Timer.Sample reconciliationTimerSample = Timer.start(metrics.meterRegistry());

    Future<Void> handler = withLock(reconciliation, LOCK_TIMEOUT_MS, () -> {
        T cr = resourceOperator.get(namespace, name);
        if (cr != null) {
            validate(cr);
            log.info("{}: {} {} should be created or updated", reconciliation, kind, name);
            return createOrUpdate(reconciliation, cr).recover(createResult -> {
                log.error("{}: createOrUpdate failed", reconciliation, createResult);
                return Future.failedFuture(createResult);
            });
        } else {
            log.info("{}: {} {} should be deleted", reconciliation, kind, name);
            return delete(reconciliation).map(deleteResult -> {
                if (deleteResult) {
                    log.info("{}: {} {} deleted", reconciliation, kind, name);
                } else {
                    log.info("{}: Assembly {} should be deleted by garbage collection", reconciliation, name);
                }
                return (Void) null;
            }).recover(deleteResult -> {
                log.error("{}: Deletion of {} {} failed", reconciliation, kind, name, deleteResult);
                return Future.failedFuture(deleteResult);
            });
        }
    });

    Promise<Void> result = Promise.promise();
    handler.onComplete(reconcileResult -> {
        handleResult(reconciliation, reconcileResult, reconciliationTimerSample);
        result.handle(reconcileResult);
    });

    return result.future();
}
 

private void stopTimer(String className, String methodName, String metricName, Timer.Sample timer) {
  long elapsedTime = timer.stop(getTimer(className, methodName, metricName));
  long elapsedTimeInSeconds = TimeUnit.MILLISECONDS.convert(elapsedTime, TimeUnit.NANOSECONDS);

  LOGGER.debug("Execution of method : {} took : {} milliseconds", metricName, elapsedTimeInSeconds);
}
 

private void stopTimer(String className, String methodName, String metricName, Timer.Sample timer) {
  long elapsedTime = timer.stop(getTimer(className, methodName, metricName));
  long elapsedTimeInSeconds = TimeUnit.MILLISECONDS.convert(elapsedTime, TimeUnit.NANOSECONDS);

  LOGGER.debug("Execution of method : {} took : {} milliseconds", metricName, elapsedTimeInSeconds);
}