Java FunctionTimer类代码示例

import io.micrometer.core.instrument.FunctionTimer; //导入依赖的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.FunctionTimer; //导入依赖的package包/类
@Override
FunctionTimer registerNewMeter(MeterRegistry registry) {
    final T obj = ref.get();
    if (obj == null) {
        return null;
    }

    return FunctionTimer.builder(getId().getName(), obj, countFunction,
                                 totalTimeFunction, totalTimeFunctionUnits)
                        .tags(getId().getTags())
                        .description(getId().getDescription())
                        .baseUnit(getId().getBaseUnit()).register(registry);
}
 

import io.micrometer.core.instrument.FunctionTimer; //导入依赖的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();
}
 

import io.micrometer.core.instrument.FunctionTimer; //导入依赖的package包/类
/**
 * For Atlas: http://localhost:7101/api/v1/graph?q=name,ftimer,:eq,:dist-avg,name,timer,:eq,:dist-avg,1,:axis&s=e-5m&l=0
 */
public static void main(String[] args) {
    MeterRegistry registry = SampleConfig.myMonitoringSystem();

    Timer timer = Timer.builder("timer")
        .publishPercentiles(0.5, 0.95)
        .register(registry);

    Object placeholder = new Object();
    AtomicLong totalTimeNanos = new AtomicLong(0);
    AtomicLong totalCount = new AtomicLong(0);

    FunctionTimer.builder("ftimer", placeholder, p -> totalCount.get(), p -> totalTimeNanos.get(), TimeUnit.NANOSECONDS)
        .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);
                totalCount.incrementAndGet();
                totalTimeNanos.addAndGet((long) TimeUtils.millisToUnit(latencyForThisSecond.get(), TimeUnit.NANOSECONDS));
            }
        })
        .blockLast();
}
 

import io.micrometer.core.instrument.FunctionTimer; //导入依赖的package包/类
private Stream<Metric> getMetrics(FunctionTimer meter) {
    return Stream.of(
        toMetric(withStatistic(meter, "count"), meter.count()),
        toMetric(withStatistic(meter, "mean"), meter.mean(getBaseTimeUnit())),
        toMetric(withStatistic(meter, "totalTime"), meter.totalTime(getBaseTimeUnit()))
    );
}
 

import io.micrometer.core.instrument.FunctionTimer; //导入依赖的package包/类
@Override
FunctionTimer newNoopMeter() {
    return new NoopFunctionTimer(getId());
}
 

import io.micrometer.core.instrument.FunctionTimer; //导入依赖的package包/类
@Override
protected <T> FunctionTimer newFunctionTimer(Id id, T obj, ToLongFunction<T> countFunction,
                                             ToDoubleFunction<T> totalTimeFunction,
                                             TimeUnit totalTimeFunctionUnits) {
    return new NoopFunctionTimer(id);
}