Spring Boot实践---JVM上的实时监控类库：Metrics

时间 2019-11-12

标签 spring boot 实践 jvm 实时监控 metrics 栏目 Spring 繁體版

原文原文链接

1、使用Metrics

系统开发到必定的阶段，线上的机器愈来愈多，就须要一些监控了，除了服务器的监控，业务方面也须要一些监控服务。Metrics做为一款监控指标的度量类库，提供了许多工具帮助开发者来完成自定义的监控工做。java

经过构建一个Spring Boot的基本应用来演示Metrics的工做方式。web

在Maven的pom.xml中引入Metrics：spring

<dependency>
    <groupId>io.dropwizard.metrics</groupId>
    <artifactId>metrics-core</artifactId>
    <version>${metrics.version}</version>
</dependency>

目前Metrics的最新版本是3.1.2。缓存

2、Metrics的基本工具

Metrics提供了五个基本的度量类型：服务器

Gauges（度量）
Counters（计数器）
Histograms（直方图数据）
Meters（TPS计算器）
Timers（计时器）

Metrics中MetricRegistry是中心容器，它是程序中全部度量的容器，全部新的度量工具都要注册到一个MetricRegistry实例中才可使用，尽可能在一个应用中保持让这个MetricRegistry实例保持单例。网络

2.1 MetricRegistry 容器

在代码中配置好这个MetricRegistry容器：app

@Bean
public MetricRegistry metrics() {
    return new MetricRegistry();
}

2.2 Meters TPS计算器

TPS计算器这个名称并不许确，Meters工具会帮助咱们统计系统中某一个事件的速率。好比每秒请求数（TPS），每秒查询数（QPS）等等。这个指标能反应系统当前的处理能力，帮助咱们判断资源是否已经不足。Meters自己是一个自增计数器。dom

经过MetricRegistry能够得到一个Meter：ide

@Bean
public Meter requestMeter(MetricRegistry metrics) {
    return metrics.meter("request");
}

在请求中调用mark()方法，来增长计数，咱们能够在不一样的请求中添加不一样的Meter，针对本身的系统完成定制的监控需求。工具

@RequestMapping("/hello")
@ResponseBody
public String helloWorld() {
    requestMeter.mark();
    return "Hello World";
}

应用运行的过程当中，在console中反馈的信息：

-- Meters ----------------------------------------------------------------------
request
             count = 21055
         mean rate = 133.35 events/second
     1-minute rate = 121.66 events/second
     5-minute rate = 36.99 events/second
    15-minute rate = 13.33 events/second

从以上信息中能够看出Meter能够为咱们提供平均速率，以及采样后的1分钟，5分钟，15分钟的速率。

2.3 Histogram 直方图数据

直方图是一种很是常见的统计图表，Metrics经过这个Histogram这个度量类型提供了一些方便实时绘制直方图的数据。

和以前的Meter相同，咱们能够经过MetricRegistry来得到一个Histogram。

@Bean
public Histogram responseSizes(MetricRegistry metrics) {
    return metrics.histogram("response-sizes");
}

在应用中，须要统计的位置调用Histogram的update()方法。

responseSizes.update(new Random().nextInt(10));

好比咱们须要统计某个方法的网络流量，经过Histogram就很是的方便。

在console中Histogram反馈的信息：

-- Histograms ------------------------------------------------------------------
response-sizes
             count = 21051
               min = 0
               max = 9
              mean = 4.55
            stddev = 2.88
            median = 4.00
              75% <= 7.00
              95% <= 9.00
              98% <= 9.00
              99% <= 9.00
            99.9% <= 9.00

Histogram为咱们提供了最大值，最小值和平均值等数据，利用这些数据，咱们就能够开始绘制自定义的直方图了。

2.4 Counter 计数器

Counter的本质就是一个AtomicLong实例，能够增长或者减小值，能够用它来统计队列中Job的总数。

经过MetricRegistry也能够得到一个Counter实例。

@Bean
public Counter pendingJobs(MetricRegistry metrics) {
    return metrics.counter("requestCount");
}

在须要统计数据的位置调用inc()和dec()方法。

// 增长计数
pendingJobs.inc();
// 减去计数
pendingJobs.dec();

console的输出很是简单：

-- Counters --------------------------------------------------------------------
requestCount
             count = 21051

只是输出了当前度量的值。

2.5 Timer 计时器

Timer是一个Meter和Histogram的组合。这个度量单位能够比较方便地统计请求的速率和处理时间。对于接口中调用的延迟等信息的统计就比较方便了。若是发现一个方法的RPS（请求速率）很低，并且平均的处理时间很长，那么这个方法八成出问题了。

一样，经过MetricRegistry获取一个Timer的实例：

@Bean
public Timer responses(MetricRegistry metrics) {
    return metrics.timer("executeTime");
}

在须要统计信息的位置使用这样的代码：

final Timer.Context context = responses.time();
try {
    // handle request
} finally {
    context.stop();
}

console中就会实时返回这个Timer的信息：

-- Timers ----------------------------------------------------------------------
executeTime
             count = 21061
         mean rate = 133.39 calls/second
     1-minute rate = 122.22 calls/second
     5-minute rate = 37.11 calls/second
    15-minute rate = 13.37 calls/second
               min = 0.00 milliseconds
               max = 0.01 milliseconds
              mean = 0.00 milliseconds
            stddev = 0.00 milliseconds
            median = 0.00 milliseconds
              75% <= 0.00 milliseconds
              95% <= 0.00 milliseconds
              98% <= 0.00 milliseconds
              99% <= 0.00 milliseconds
            99.9% <= 0.01 milliseconds

2.6 Gauges 度量

除了Metrics提供的几个度量类型，咱们能够经过Gauges完成自定义的度量类型。比方说很简单的，咱们想看咱们缓存里面的数据大小，就能够本身定义一个Gauges。

metrics.register(
                MetricRegistry.name(ListManager.class, "cache", "size"),
                (Gauge<Integer>) () -> cache.size()
        );

这样Metrics就会一直监控Cache的大小。

除此以外有时候，咱们须要计算本身定义的一直单位，好比消息队列里面消费者(consumers)消费的速率和生产者(producers)的生产速率的比例，这也是一个度量。

public class CompareRatio extends RatioGauge {

    private final Meter consumers;
    private final Meter producers;

    public CacheHitRatio(Meter consumers, Meter producers) {
        this.consumers = consumers;
        this.producers = producers;
    }

    @Override
    protected Ratio getRatio() {
        return Ratio.of(consumers.getOneMinuteRate(),
                producers.getOneMinuteRate());
    }
}

把这个类也注册到Metrics容器里面：

@Bean
public CompareRatio cacheHitRatio(MetricRegistry metrics, Meter requestMeter, Meter producers) {

    CompareRatio compareRatio = new CompareRatio(consumers, producers);

    metrics.register("生产者消费者比率", compareRatio);

    return cacheHitRatio;
}

3、Reporter 报表

Metrics经过报表，将采集的数据展示到不一样的位置,这里好比咱们注册一个ConsoleReporter到MetricRegistry中，那么console中就会打印出对应的信息。

@Bean
public ConsoleReporter consoleReporter(MetricRegistry metrics) {
    return ConsoleReporter.forRegistry(metrics)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
}

除此以外Metrics还支持JMX、HTTP、Slf4j等等，能够访问 http://metrics.dropwizard.io/3.1.0/manual/core/#reporters 来查看Metrics提供的报表，若是仍是不能知足本身的业务，也能够本身继承Metrics提供的ScheduledReporter类完成自定义的报表类。

4、完整的代码

这个demo是在一个很简单的spring boot下运行的，关键的几个类完整代码以下。

配置类MetricConfig.java

package demo.metrics.config;

import com.codahale.metrics.*;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@Configuration
public class MetricConfig {

    @Bean
    public MetricRegistry metrics() {
        return new MetricRegistry();
    }

    /**
     * Reporter 数据的展示位置
     *
     * @param metrics
     * @return
     */
    @Bean
    public ConsoleReporter consoleReporter(MetricRegistry metrics) {
        return ConsoleReporter.forRegistry(metrics)
                .convertRatesTo(TimeUnit.SECONDS)
                .convertDurationsTo(TimeUnit.MILLISECONDS)
                .build();
    }

    @Bean
    public Slf4jReporter slf4jReporter(MetricRegistry metrics) {
        return Slf4jReporter.forRegistry(metrics)
                .outputTo(LoggerFactory.getLogger("demo.metrics"))
                .convertRatesTo(TimeUnit.SECONDS)
                .convertDurationsTo(TimeUnit.MILLISECONDS)
                .build();
    }

    @Bean
    public JmxReporter jmxReporter(MetricRegistry metrics) {
        return JmxReporter.forRegistry(metrics).build();
    }

    /**
     * 自定义单位
     *
     * @param metrics
     * @return
     */
    @Bean
    public ListManager listManager(MetricRegistry metrics) {
        return new ListManager(metrics);
    }

    /**
     * TPS 计算器
     *
     * @param metrics
     * @return
     */
    @Bean
    public Meter requestMeter(MetricRegistry metrics) {
        return metrics.meter("request");
    }

    /**
     * 直方图
     *
     * @param metrics
     * @return
     */
    @Bean
    public Histogram responseSizes(MetricRegistry metrics) {
        return metrics.histogram("response-sizes");
    }

    /**
     * 计数器
     *
     * @param metrics
     * @return
     */
    @Bean
    public Counter pendingJobs(MetricRegistry metrics) {
        return metrics.counter("requestCount");
    }

    /**
     * 计时器
     *
     * @param metrics
     * @return
     */
    @Bean
    public Timer responses(MetricRegistry metrics) {
        return metrics.timer("executeTime");
    }

}

接收请求的类MainController.java

package demo.metrics.action;

import com.codahale.metrics.Counter;
import com.codahale.metrics.Histogram;
import com.codahale.metrics.Meter;
import com.codahale.metrics.Timer;
import demo.metrics.config.ListManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Random;

@Controller
@RequestMapping("/")
public class MainController {

    @Autowired
    private Meter requestMeter;

    @Autowired
    private Histogram responseSizes;

    @Autowired
    private Counter pendingJobs;

    @Autowired
    private Timer responses;

    @Autowired
    private ListManager listManager;

    @RequestMapping("/hello")
    @ResponseBody
    public String helloWorld() {

        requestMeter.mark();

        pendingJobs.inc();

        responseSizes.update(new Random().nextInt(10));

        listManager.getList().add(1);

        final Timer.Context context = responses.time();
        try {
            return "Hello World";
        } finally {
            context.stop();
        }
    }
}

项目启动类DemoApplication.java：

package demo.metrics;

import com.codahale.metrics.ConsoleReporter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

import java.util.concurrent.TimeUnit;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        ApplicationContext ctx = SpringApplication.run(DemoApplication.class, args);

        // 启动Reporter
        ConsoleReporter reporter = ctx.getBean(ConsoleReporter.class);
        reporter.start(1, TimeUnit.SECONDS);
    }
}