import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@Test
@DisplayName("callable task that throws exception is still recorded")
default void recordCallableException(MeterRegistry registry) {
    Timer t = registry.timer("myTimer");

    assertThrows(Exception.class, () -> {
        t.recordCallable(() -> {
            clock(registry).add(10, TimeUnit.NANOSECONDS);
            throw new Exception("uh oh");
        });
    });

    clock(registry).add(step());

    assertAll(() -> assertEquals(1L, t.count()),
            () -> assertEquals(10, t.totalTime(TimeUnit.NANOSECONDS), 1.0e-12));
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
private void record(TimingSampleContext timingContext, HttpServletResponse response, HttpServletRequest request,
                    Object handlerObject, Throwable e) {
    for (Timed timedAnnotation : timingContext.timedAnnotations) {
        timingContext.timerSample.stop(Timer.builder(timedAnnotation, metricName)
            .tags(tagsProvider.httpRequestTags(request, response, handlerObject, e))
            .register(registry));
    }

    if(timingContext.timedAnnotations.isEmpty() && autoTimeRequests) {
        timingContext.timerSample.stop(Timer.builder(metricName)
            .tags(tagsProvider.httpRequestTags(request, response, handlerObject, e))
            .register(registry));
    }

    for (LongTaskTimer.Sample sample : timingContext.longTaskTimerSamples) {
        sample.stop();
    }
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
private void time(CallState state) {
    String uri = state.response == null ? "UNKNOWN" :
        (state.response.code() == 404 || state.response.code() == 301 ? "NOT_FOUND" : urlMapper.apply(state.request));

    Iterable<Tag> tags = Tags.concat(extraTags, Tags.zip(
        "method", state.request != null ? state.request.method() : "UNKNOWN",
        "uri", uri,
        "status", getStatusMessage(state.response, state.exception),
        "host", state.request != null ? state.request.url().host() : "UNKNOWN"
    ));

    Timer.builder(this.requestsMetricName)
        .tags(tags)
        .description("Timer of OkHttp operation")
        .register(registry)
        .record(registry.config().clock().monotonicTime() - state.startTime, TimeUnit.NANOSECONDS);
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@Override
Timer registerNewMeter(MeterRegistry registry) {
    final long[] slaNanos = histogramConfig.getSlaBoundaries();

    Duration[] sla = null;
    if(slaNanos != null) {
        sla = new Duration[slaNanos.length];
        for (int i = 0; i < slaNanos.length; i++) {
            sla[i] = Duration.ofNanos(slaNanos[i]);
        }
    }

    return Timer.builder(getId().getName())
                .tags(getId().getTags())
                .description(getId().getDescription())
                .maximumExpectedValue(Duration.ofNanos(histogramConfig.getMaximumExpectedValue()))
                .minimumExpectedValue(Duration.ofNanos(histogramConfig.getMinimumExpectedValue()))
                .publishPercentiles(histogramConfig.getPercentiles())
                .publishPercentileHistogram(histogramConfig.isPercentileHistogram())
                .histogramBufferLength(histogramConfig.getHistogramBufferLength())
                .histogramExpiry(histogramConfig.getHistogramExpiry())
                .sla(sla)
                .pauseDetector(pauseDetector)
                .register(registry);
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
private Set<Timer> shortTimers(Set<Timed> timed, RequestEvent event) {
    /*
     * Given we didn't find any matching resource method, 404s will be only
     * recorded when auto-time-requests is enabled. On par with WebMVC
     * instrumentation.
     */
    if ((timed == null || timed.isEmpty()) && autoTimeRequests) {
        return Collections.singleton(registry.timer(metricName, tagsProvider.httpRequestTags(event)));
    }

    if(timed == null) {
        return Collections.emptySet();
    }

    return timed.stream()
        .map(t -> Timer.builder(t, metricName).tags(tagsProvider.httpRequestTags(event)).register(registry))
        .collect(Collectors.toSet());
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@GetMapping("/api/stats")
public Map<String, Number> stats() {
    Timer t = registry.find("http.server.requests").tags("uri", "/api/people").timer();

    Map<String, Number> result = null;

    if(t != null){
        result = new HashMap<>();

        result.put("count", t.count());
        result.put("max", t.max(TimeUnit.MILLISECONDS));
        result.put("mean", t.mean(TimeUnit.MILLISECONDS));
        result.put("50.percentile", t.percentile(0.5, TimeUnit.MILLISECONDS));
        result.put("95.percentile", t.percentile(0.95, TimeUnit.MILLISECONDS));
    }
    return result;


}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@Override
protected void publish() {
    List<Metric> metrics = getMeters().stream()
        .flatMap(meter -> {
            if (meter instanceof DistributionSummary) {
                return getMetrics((DistributionSummary) meter);
            } else if (meter instanceof FunctionTimer) {
                return getMetrics((FunctionTimer) meter);
            } else if (meter instanceof Timer) {
                return getMetrics((Timer) meter);
            } else {
                return getMetrics(meter);
            }
        })
        .collect(Collectors.toList());

    this.metricPublisher.publish(metrics);
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
DataSourceMetricsHolder(String dataSourceName, DataSourcePoolMetadata poolMetadata, MeterRegistry registry) {
    connectionObtainTimer = Timer.builder("data.source.connections.wait")
            .tags("pool", dataSourceName)
            .register(registry);

    connectionUsageTimer = Timer.builder("data.source.connections.usage")
            .tags("pool", dataSourceName)
            .register(registry);

    connectionCreatedCounter = Counter.builder("data.source.connections.created")
            .tags("pool", dataSourceName)
            .register(registry);

    connectionFailedCounter = Counter.builder("data.source.connections.failed")
            .tags("pool", dataSourceName)
            .register(registry);

    Gauge.builder("data.source.connections.active", this, metrics -> activeConnections.doubleValue())
            .tags("pool", dataSourceName)
            .register(registry);

    Gauge.builder("data.source.connections.pending", this, metrics -> pendingConnections.doubleValue())
            .tags("pool", dataSourceName)
            .register(registry);

    if (poolMetadata != null) {
        Gauge.builder("data.source.connections.max", this, metrics -> poolMetadata.getMax())
                .tags("pool", dataSourceName)
                .register(registry);

        Gauge.builder("data.source.connections.min", this, metrics -> poolMetadata.getMin())
                .tags("pool", dataSourceName)
                .register(registry);
    }
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@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;
    }
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@Test
@DisplayName("total time and count are preserved for a single timing")
default void record(MeterRegistry registry) {
    Timer t = registry.timer("myTimer");
    t.record(42, TimeUnit.MILLISECONDS);
    clock(registry).add(step());

    assertAll(() -> assertEquals(1L, t.count()),
            () -> assertEquals(42, t.totalTime(TimeUnit.MILLISECONDS), 1.0e-12));
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@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));
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@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));
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@Test
@DisplayName("zero times contribute to the count of overall events but do not add to total time")
default void recordZero(MeterRegistry registry) {
    Timer t = registry.timer("myTimer");
    t.record(0, TimeUnit.MILLISECONDS);
    clock(registry).add(step());

    assertAll(() -> assertEquals(1L, t.count()),
            () -> assertEquals(0L, t.totalTime(TimeUnit.NANOSECONDS)));
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@Test
@DisplayName("record a runnable task")
default void recordWithRunnable(MeterRegistry registry) throws Exception {
    Timer t = registry.timer("myTimer");

    try {
        t.record(() -> clock(registry).add(10, TimeUnit.NANOSECONDS));
        clock(registry).add(step());
    } finally {
        assertAll(() -> assertEquals(1L, t.count()),
                () -> assertEquals(10, t.totalTime(TimeUnit.NANOSECONDS) ,1.0e-12));
    }
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@Test
@DisplayName("record with stateful Sample instance")
default void recordWithSample(MeterRegistry registry) throws Exception {
    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));
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@Test
default void recordMax(MeterRegistry registry) {
    Timer timer = registry.timer("my.timer");
    timer.record(10, TimeUnit.MILLISECONDS);
    timer.record(1, TimeUnit.SECONDS);

    clock(registry).add(step()); // for Atlas, which is step rather than ring-buffer based
    assertThat(timer.max(TimeUnit.SECONDS)).isEqualTo(1);
    assertThat(timer.max(TimeUnit.MILLISECONDS)).isEqualTo(1000);

    clock(registry).add(Duration.ofMillis(step().toMillis() * HistogramConfig.DEFAULT.getHistogramBufferLength()));
    assertThat(timer.max(TimeUnit.SECONDS)).isEqualTo(0);
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
private Object recordThrowable(Timer timer, ThrowableCallable f) throws Throwable {
    long start = registry.config().clock().monotonicTime();
    try {
        return f.call();
    } finally {
        timer.record(registry.config().clock().monotonicTime() - start, TimeUnit.NANOSECONDS);
    }
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
TimingSampleContext(HttpServletRequest request, Object handlerObject) {
    timedAnnotations = annotations(handlerObject);
    timerSample = Timer.start(registry);
    longTaskTimerSamples = timedAnnotations.stream()
        .filter(Timed::longTask)
        .map(t -> LongTaskTimer.builder(t)
            .tags(tagsProvider.httpLongRequestTags(request, handlerObject))
            .register(registry)
            .start())
        .collect(Collectors.toList());
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
@Test
void timerMax() {
    AtlasConfig atlasConfig = k -> null;
    AtlasMeterRegistry registry = new AtlasMeterRegistry(atlasConfig, new MockClock());
    Timer timer = registry.timer("timer");

    timer.record(1, TimeUnit.SECONDS);
    clock(registry).add(atlasConfig.step());
    assertThat(timer.max(TimeUnit.MILLISECONDS)).isEqualTo(1000);
}
 

import io.micrometer.core.instrument.Timer; //导入依赖的package包/类
public static void main(String[] args) {
    MeterRegistry registry = SampleConfig.myMonitoringSystem();
    Timer timer = Timer.builder("timer")
        .publishPercentileHistogram()
        .publishPercentiles(0.5, 0.95, 0.99)
        .histogramExpiry(Duration.ofSeconds(10))
        .histogramBufferLength(3)
        .register(registry);

    FunctionTimer.builder("ftimer", timer, Timer::count, t -> t.totalTime(TimeUnit.SECONDS), TimeUnit.SECONDS)
        .register(registry);

    RandomEngine r = new MersenneTwister64(0);
    Normal incomingRequests = new Normal(0, 1, r);
    Normal duration = new Normal(250, 50, r);

    AtomicInteger latencyForThisSecond = new AtomicInteger(duration.nextInt());
    Flux.interval(Duration.ofSeconds(1))
        .doOnEach(d -> latencyForThisSecond.set(duration.nextInt()))
        .subscribe();

    // the potential for an "incoming request" every 10 ms
    Flux.interval(Duration.ofMillis(10))
            .doOnEach(d -> {
                if (incomingRequests.nextDouble() + 0.4 > 0) {
                    // pretend the request took some amount of time, such that the time is
                    // distributed normally with a mean of 250ms
                    timer.record(latencyForThisSecond.get(), TimeUnit.MILLISECONDS);
                }
            })
            .blockLast();
}