微服务性能监控系列-基于Metrics的实时监控系统

原文链接

Metrics是一个提供服务性能检测工具的Java类库，它提供了功能强大的性能指标工具库用于度量生产环境中的各关键组件性能。

度量类型

Metrics提供了以下几种基本的度量类型：

• Gauge：用于提供自定义度量。
• Counter：计数器，本质是一个java.util.concurrent.atomic.LongAdder。
• Histogram：直方图数据。
• Meter：统计系统中某一事件的响应速率，如TPS、QPS。该项指标值直接反应系统当前的处理能力
• Timer：计时器，是Meter和Histogram的结合，可以统计接口请求速率和响应时长。

Gauge

Gauge是对一项值的瞬时度量。我们可以通过实现Gauge接口来根据业务场景自定义度量。

例如，想要度量队列中处于等待状态的作业数量：

public class QueueManager {
    private final Queue queue;

    public QueueManager(MetricRegistry metrics, String name) {
        this.queue = new Queue();
        // 通过MetricRegistry 的register方法注册Gauge度量
        metrics.register(MetricRegistry.name(QueueManager.class, name, "size"),
                         new Gauge() {
                             @Override
                             public Integer getValue() {
                                 return queue.size();
                             }
                         });
    }
}

官方目前提供了以下几种Gauge实现：

Counter

Counter是一个常规计数器，用于对某项指标值进行累加或者递减操作。

Counter本质是一个java.util.concurrent.atomic.LongAdder，在多线程同时更新计数器的场景下，当并发量较大时，LongAdder比AtomicLong具有更高的吞吐量，当然空间资源消耗也更大一些。

final Counter evictions = registry.counter(name(SessionStore.class, "cache-evictions"));
evictions.inc();
evictions.inc(3);
evictions.dec();
evictions.dec(2);

Histograms

Histogram反应的是数据流中的值的分布情况。包含最小值、最大值、平均值、中位数、p75、p90、p95、p98、p99以及p999数据分布情况。

private final Histogram responseSizes = metrics.histogram(name(RequestHandler.class, "response-sizes"));

public void handleRequest(Request request, Response response) {
    // etc
    responseSizes.update(response.getContent().length);
}

Histogram计算分位数的方法是先对整个数据集进行排序，然后取排序后的数据集中特定位置的值（比如p99就是取倒序1%位置的值）。这种方式适合于小数据集或者批处理系统，不适用于要求高吞吐量、低延时的服务。

对于数据量较大，系统对吞吐量、时延要求较大的场景，我们可以采用抽样的方式获取数据。通过动态地抽取程序运行过程中的能够代表系统真实运行情况的一小部分数据来实现对整个系统运行指标的近似度量，这种方法叫做蓄水池算法（reservoir sampling）。

Metrics中提供了各式各样的Reservoir实现：

Meter

Meter用于度量事件响应的平均速率，它表示的是应用程序整个运行生命周期内的总速率（总请求响应量/处理请求的总毫秒数，即每秒请求数）。

除此之外，Meter还提供了1分钟、5分钟以及15分钟的动态平均响应速率。

final Meter getRequests = registry.meter(name(WebProxy.class, "get-requests", "requests"));
getRequests.mark();
getRequests.mark(requests.size());

Timer

Timer会度量服务的响应速率，同时也会统计服务响应时长的分布情况。

final Timer timer = registry.timer(name(WebProxy.class, "get-requests"));

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

---

Reporters

通过上述各项度量监测服务指标后，我们可以通过Reporters报表导出度量结果。metrics-core模块中实现了以下几种导出指标的Report：

Console Reporters

定时向控制台发送服务的各项指标数据。

final ConsoleReporter reporter = ConsoleReporter.forRegistry(registry)
                                                .convertRatesTo(TimeUnit.SECONDS)
                                                .convertDurationsTo(TimeUnit.MILLISECONDS)
                                                .build();
reporter.start(1, TimeUnit.MINUTES);

CsvReporter

定时向给定目录下的.csv文件追加服务各项指标数据。对于每一项指标都会在指定目录下创建一个.csv文件，然后定时（本例中是1s）向每个文件中追加指标最新数据。

final CsvReporter reporter = CsvReporter.forRegistry(registry)
                                        .formatFor(Locale.US)
                                        .convertRatesTo(TimeUnit.SECONDS)
                                        .convertDurationsTo(TimeUnit.MILLISECONDS)
                                        .build(new File("~/projects/data/"));
reporter.start(1, TimeUnit.SECONDS);

JmxReporter

将服务的各项度量指标通过JMX MBeans暴露出来，之后可以使用VisualVM查看指标数据。生产环境不建议使用。

final JmxReporter reporter = JmxReporter.forRegistry(registry).build();
reporter.start();

Slf4jReporter

Slf4jReporter允许我们将服务的指标数据作为日志记录到日志文件中。

final Slf4jReporter reporter = Slf4jReporter.forRegistry(registry)
                                            .outputTo(LoggerFactory.getLogger("com.example.metrics"))
                                            .convertRatesTo(TimeUnit.SECONDS)
                                            .convertDurationsTo(TimeUnit.MILLISECONDS)
                                            .build();
reporter.start(1, TimeUnit.MINUTES);

---

如何使用

直接引用

直接依赖Metrics的核心库，通过其提供的各类API完成服务指标数据度量。

1. 引入Maven依赖

  io.dropwizard.metrics
  metrics-core
  ${metrics.version}

1. 创建一个MetricRegistry对象，它是Metrics类库的核心类，所有的应用指标都需要注册到MetricRegistry。

// 实例化MetricsRegistry
final MetricRegistry metrics = new MetricRegistry();

// 开启Console Reporter
startConsoleReporter();

Meter requests = metrics.meter(name(MetricsConfig.class, "requests", "size"));
requests.mark();

void startReport() {
    ConsoleReporter reporter = ConsoleReporter.forRegistry(metrics)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
    reporter.start(1, TimeUnit.SECONDS);
}

整合Spring

1. 引入Maven依赖

    com.ryantenney.metrics
    metrics-spring
    3.1.3

1. 通过Java注解配置Metrics。

import java.util.concurrent.TimeUnit;
import org.springframework.context.annotation.Configuration;
import com.codahale.metrics.ConsoleReporter;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.SharedMetricRegistries;
import com.ryantenney.metrics.spring.config.annotation.EnableMetrics;
import com.ryantenney.metrics.spring.config.annotation.MetricsConfigurerAdapter;

@Configuration
@EnableMetrics
public class SpringConfiguringClass extends MetricsConfigurerAdapter {

    @Override
    public void configureReporters(MetricRegistry metricRegistry) {
        // registerReporter allows the MetricsConfigurerAdapter to
        // shut down the reporter when the Spring context is closed
        registerReporter(ConsoleReporter
            .forRegistry(metricRegistry)
            .build())
            .start(1, TimeUnit.MINUTES);
    }

}


@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({DelegatingMetricsConfiguration.class})
public @interface EnableMetrics {
    // 默认false表示使用JDK动态代理，设置为true时表示使用CGLIB动态代理（当使用基于类的服务暴露方式时）
    boolean exposeProxy() default false;
    // 设置为true时，目标对象可以通过AopContext.currentProxy()访问封装它的代理
    boolean proxyTargetClass() default false;
}

使用限制

因为Spring AOP中，只有声明为public的方法可以被代理，所以@Timed, @Metered, @ExceptionMetered以及 @Counted在non-public无法生效。

因为@Gauge注解不涉及代理，所以它可以被应用在non-public属性和方法上。

public class MetricsBeanPostProcessorFactory {
    private MetricsBeanPostProcessorFactory() {
    }

    public static AdvisingBeanPostProcessor exceptionMetered(MetricRegistry metricRegistry, ProxyConfig proxyConfig) {
        return new AdvisingBeanPostProcessor(ExceptionMeteredMethodInterceptor.POINTCUT, ExceptionMeteredMethodInterceptor.adviceFactory(metricRegistry), proxyConfig);
    }

    public static AdvisingBeanPostProcessor metered(MetricRegistry metricRegistry, ProxyConfig proxyConfig) {
        return new AdvisingBeanPostProcessor(MeteredMethodInterceptor.POINTCUT, MeteredMethodInterceptor.adviceFactory(metricRegistry), proxyConfig);
    }

    public static AdvisingBeanPostProcessor timed(MetricRegistry metricRegistry, ProxyConfig proxyConfig) {
        return new AdvisingBeanPostProcessor(TimedMethodInterceptor.POINTCUT, TimedMethodInterceptor.adviceFactory(metricRegistry), proxyConfig);
    }

    public static AdvisingBeanPostProcessor counted(MetricRegistry metricRegistry, ProxyConfig proxyConfig) {
        return new AdvisingBeanPostProcessor(CountedMethodInterceptor.POINTCUT, CountedMethodInterceptor.adviceFactory(metricRegistry), proxyConfig);
    }

    public static GaugeFieldAnnotationBeanPostProcessor gaugeField(MetricRegistry metricRegistry) {
        return new GaugeFieldAnnotationBeanPostProcessor(metricRegistry);
    }

    public static GaugeMethodAnnotationBeanPostProcessor gaugeMethod(MetricRegistry metricRegistry) {
        return new GaugeMethodAnnotationBeanPostProcessor(metricRegistry);
    }

    public static CachedGaugeAnnotationBeanPostProcessor cachedGauge(MetricRegistry metricRegistry) {
        return new CachedGaugeAnnotationBeanPostProcessor(metricRegistry);
    }

    public static MetricAnnotationBeanPostProcessor metric(MetricRegistry metricRegistry) {
        return new MetricAnnotationBeanPostProcessor(metricRegistry);
    }

    public static HealthCheckBeanPostProcessor healthCheck(HealthCheckRegistry healthRegistry) {
        return new HealthCheckBeanPostProcessor(healthRegistry);
    }
}

除此此外，在一个方法中调用处于同一个类中的另一个带有Metrics注解的方法时，方法执行流程不会经过代理。