使用 Micrometer 来测量系统指标

image.png

介绍

在该项目的 Github 首页中是这样介绍的：

An application metrics facade for the most popular monitoring tools
Micrometer.Think SLF4J, but for metrics

翻译过来就是：最流行的监控工具之应用程序指标收集门面，像 SL4J，但只适用于监控指标收集。
这里如果熟悉 SL4J 的话，可能马上恍然大悟，因为 SL4J 其实本身就是使用了门面模式来适配不同的日志框架，并提供许多高效、通过的功能。

Micrometer 是一个只提供指标收集的工具，通过它可以避免使用具体某个监控系统有关的接口和方法，而是使用 Micrometer 提供的通用的接口和方法，并可以同时将收集的监控指标发送到不同监控系统中，最新的版本与大多数市面流行监控系统都适配，如：AppOptics, Azure Monitor, Netflix Atlas, CloudWatch, Datadog, Dynatrace, Elastic, Ganglia, Graphite, Humio, Influx/Telegraf, JMX, KairosDB, New Relic, Prometheus, SignalFx, Google Stackdriver, StatsD, and Wavefront

注册表

注册表 MeterRegistry，提供了获取指标 Meter 的能力。每一个监控系统都有对应实现 MeterRegistry 的注册表，Micrometer 提供了一个基于内存的注册表 SimpleMeterRegistry ，它将会把指标 Meter 收集到的最新的 measurements 监控数据（尺寸、大小）存放到内存中，如果在还没确定好一个监控系统，或测试阶段，可以使用它来进行测量

指标

Meter 是一个接口用来提供了收集 measurements 监控数据（尺寸、大小）的能力，并且是所有原生指标的顶层的接口，原生的指标包含了：Timer, Counter, Gauge, DistributionSummary, LongTaskTimer, FunctionCounter, FunctionTimer, TimeGauge , Meter 指标根据不同的 name 和 Tag 来标识唯一性

Tags 该工具类提供了快捷生成 tag 的方法

Tags tags = Tags.of("key", "value")
    .and("a", "b");
meterRegistry.counter("count", tags);

Counter 计数器

Counter 只会报告单个指标（其他的如 Timer 将会同时记录 sum 和 count），Counter 可以增加一个可选的值，且该值必须是正数，默认为 1。
Timer 指标将同时记录 xxx_sum 和 xxx_count,
注意：不要将 Counter 指标与其他重复使用，如当使用 Timer 记录了某个接口的请求时间，那么同时记录 xxx_sum:总耗时 和 xxx_count：总请求次数, 此时再使用 Counter 去单独记录该接口的请求次数是多余的。

Counter 指标常用来记录某些将一直正增长的数据，如 请求次数、变化次数，通过在对应监控系统使用聚合函数，如 rate、increase 等，可以计算出指标在指定时间范围的变化率，也就是通常说的 QPS

假设使用的 meterRegistry 为 SimpleMeterRegistry

MeterRegistry meterRegistry = new SimpleMeterRegistry()

使用 MeterRegistry api 来创建 Counter 对象

Counter counter = meterRegistry.counter("http.request", "method", "/order/create");
counter.increment();
System.out.println(counter.measure());

1. 通过 meterRegistry.counter 来创建了一个 name 为：http.request ，含有一个 tag 键值对：method与/order/create
2. counter.increment(); 或者 counter.increment(n); 来增加该 counter 的数量

通过 Counter 的 fluent api 来创建 Counter 对象

Counter counter = Counter.builder("http.request") // -> 名称
    .baseUnit("ms") // -> 基础单位
    .description("desc") // -> 描述
    .tag("method", "/order/create") // tag 标签
    .register(newmeterRegistry);// 绑定的 MeterRegistry
counter.increment();
System.out.println(counter.measure());

1. 除了 name http.request 其他都是可选的

使用函数式接口

AtomicInteger n = new AtomicInteger(0);
FunctionCounter functionCounter = FunctionCounter
    .builder("functionCounter", n, AtomicInteger::get)
    .baseUnit("unit")
    .description("desc")
    .tag("key", "value")
    .register(meterRegistry);
n.incrementAndGet();
n.incrementAndGet();
n.incrementAndGet();
System.out.println(functionCounter.measure());

1. jdk8 中，Micrometer 将 counter 计数器累加的动作暴露出来，并通过 ToDoubleFunction 这个函数式接口来获取计数器的内容
2. FunctionCounter.builder 中接受三个参数：1. counter 名称 2. 3 中执行的对象 3. ToDoubleFunction 中 apply 方法的实现
   注：
   调用了 n.decrementAndGet(); 方法后，可以将 counter 的值减少

Gauges

一般用于监测有自然上限的事件或任务，而 Counter 一般用于无自然上限的事件或任务。有自然上限:如内存使用大小、容器大小、运行中的线程数量等。

使用 ToDoubleFunction 记录 Gauges

ArrayList list = meterRegistry
    .gauge("listGauge", Tags.of("key", "value"), new ArrayList<>(), List::size); //1
List list2 = meterRegistry
    .gaugeCollectionSize("listSize2", Tags.empty(), new ArrayList<>()); //2
Map map = meterRegistry
    .gaugeMapSize("mapGauge", Tags.empty(), new HashMap<>()); //3

1. meterRegistry.gauge 方法提供四个参数，
   1. gauge 名称
   2. tag键值对
   3. 4 中执行的对象
   4. ToDoubleFunction 函数式方法实现
2. meterRegistry.gaugeCollectionSize 则是将 meterRegistry.gauge 方法封装了一下，简化操作
3. 同2
   注意：所有调用方法创建 Gauge 时仅保持对要观察的对象的弱引用，以免阻止对象的垃圾收集

使用 Number 子类记录 Gauges

AtomicInteger integerGauge = meterRegistry.gauge("aiIntegerGauge", new AtomicInteger(0));
integerGauge.getAndIncrement();
integerGauge.getAndIncrement();
integerGauge.getAndIncrement();
integerGauge.decrementAndGet();
AtomicLong longGauge = meterRegistry.gauge("aiLongGauge", new AtomicLong(0));
longGauge.getAndIncrement();
meterRegistry.getMeters().forEach(e -> {
  System.out.println(e.measure());
});

与其他指标 meter 不同的地方是，其他指标将在创建之后可以引用创建之后的对象，但 Gauge 指标不行，而只能去观察该事件，这是因为 heisen-gauge 原理，指标一经创建便是自给自足的，因此您无需与之交互。 这使我们可以只向您退还已观察的对象，从而可以快速创建一个可观察对象并围绕该对象设置指标数据

使用 fluent builder 创建 Gauge

  @Test
  public void TestFluent() {
    GaugeMonitor gaugeMonitor = new GaugeMonitor();
    Gauge.builder("fluentGauge", gaugeMonitor, gaugeMonitor::getGaugeValue)
        .tags(Tags.of("aa", "bb"))
        .description("xx")
        .baseUnit("xx")
        .strongReference(true)
        .register(meterRegistry);
    gaugeMonitor.doSomething();
    gaugeMonitor.doSomething();
    System.out.println(gauge.measure());
  }

  public static class GaugeMonitor {

    double gaugeValue = 0;

    public void doSomething() {
      gaugeValue++;
    }

    public double getGaugeValue(GaugeMonitor gaugeMonitor) {
      return gaugeMonitor.gaugeValue;
    }
  }

1. 返回的 Gauge 对象除了测试没有其他用处，因为 gauge 在注册到 MeterRegistry 时，已经被设置为自动跟踪
2. strongReference(true) 可以将 Gauge 引用的对象设置为强引用，但不要将一些将可能被垃圾收集的对象设置强引用，将会造成不必要的内存泄露, 如果指标数据中出现 NaN，可能是 gauge 弱引用的对象被垃圾回收

Timer

Timer 指标常用于记录短时间的延迟及事件发生的次数。所有 Timer 的实现类至少提供 2 个指标：总次数和总耗时

    /**
     * @return The number of times that stop has been called on this timer.
     */
    long count();

    /**
     * @param unit The base unit of time to scale the total to.
     * @return The total time of recorded events.
     */
    double totalTime(TimeUnit unit);

使用 Timer 记录较短时高频率的时间

    Timer timer = meterRegistry.timer("http.request", "method", "/order/create");
    timer.record(100, TimeUnit.MILLISECONDS);
    timer.record(Duration.ofMillis(100));

当需要在每秒更新多次时，可使用 record 方法记录当前耗时

使用 fluent 创建Timer

    Timer timer = Timer.builder("my.timer")
        .description("desc")
        .tag("key", "value")
        .register(meterRegistry);

使用函数式编程记录代码块耗时

 T record(Supplier f);
 T recordCallable(Callable f) throws Exception;
void record(Runnable f);

timer.record(() -> {
  createOrder();
});

将开始状态存放到 Timer.Sample 中
也可以将启动状态存储在 Timer.Sample 中，后面可以将其停止。 Sample 类根据 MeterRegistry 的 Clock 记录开始时间。 开始采样后，执行要计时的代码，并通过对采样调用 stop（Timer）来完成操作。

Timer timer = ...
Sample sample = Timer.start(meterRegistry);
//业务逻辑操作
createOrder();
sample.stop(timer);

如果一个任务的耗时很长，直接使用 Timer 并不是一个好的选择，因为 Timer 只有在任务完成之后才会记录时间。更好的选择是使用 LongTaskTimer。LongTaskTimer 可以在任务进行中记录已经耗费的时间，它通过注册表的 more().longTaskTimer()

LongTaskTimer longTaskTimer = meterRegistry.more().longTaskTimer("tagName", "key1", "value1");
longTaskTimer.record(() -> {
  //执行的任务
  new java.util.Timer().schedule(new TimerTask() {
    Integer i = 0;

    @Override
    public void run() {
      System.out.println("timer task executing-" + i++);
    }
  }, 1000);
});
TimeUnit.SECONDS.sleep(10);
System.out.println(longTaskTimer.measure());

Distribution summary

summary用于跟踪事件的分发。 它在结构上类似于计时器，但记录的值不代表时间单位。 例如，分发摘要可用于衡量命中服务器的请求的有效负载大小。

创建 summary

DistributionSummary summary = meterRegistry.summary("summary", Tags.of("key", "value"));

使用 fluent 方式创建

DistributionSummary summary = DistributionSummary.builder("summary")
    .baseUnit("xx")
    .description("xx")
    .scale(10)
    .publishPercentiles(0.5, 0.75, 0.9)
    .minimumExpectedValue(1L)
    .maximumExpectedValue(10L)
    .register(meterRegistry);
summary.record(0.1);
summary.record(0.2);
summary.record(0.3);
System.out.println(summary.takeSnapshot());

Micrometer 默认的桶的值从 1 到最大的 long 值。可以通过 minimumExpectedValue 和 maximumExpectedValue 来控制值的范围。如果事件所对应的值较小，可以通过 scale 来设置一个值来对数值进行放大。与分布概要密切相关的是直方图和百分比（percentile）。大多数时候，我们并不关注具体的数值，而是数值的分布区间。比如在查看 HTTP 服务响应时间的性能指标时，通常关注是的几个重要的百分比，如 50%，75%和 90%等。所关注的是对于这些百分比数量的请求都在多少时间内完成。Micrometer 提供了两种不同的方式来处理百分比。

Histogram

通过Timer的 publishPercentileHistogram 方法发布直方图,把预定的一组 buckets 运送到监视系统,监视系统的查询语言负责计算此直方图的百分位数,因此与 Distribution Summary 对比起来，histograms 则是在监控系统进行计算

Timer.builder("my.timer")
   .publishPercentiles(0.5, 0.95) // median and 95th percentile
   .publishPercentileHistogram()
   .sla(Duration.ofMillis(100))
   .minimumExpectedValue(Duration.ofMillis(1))
   .maximumExpectedValue(Duration.ofSeconds(10))