微服务17-Java服务监控：使用Micrometer与Prometheus构建全方位监控体系

Java服务监控：使用Micrometer与Prometheus构建全方位监控体系

在这个"一切皆可观测"的时代，一个没有监控的系统就像一辆没有仪表盘的汽车——你永远不知道它什么时候会抛锚。对于Java服务而言，有效的监控不仅能帮助我们提前发现问题，还能为性能优化提供数据支持，甚至在故障发生时快速定位根源。

本文将带你深入了解如何使用Micrometer和Prometheus构建强大的Java服务监控体系，让你的对服务的运行状态了如指掌。

一、监控的重要性：为什么我们需要监控？

想象一下，你负责的Java服务突然变慢，用户投诉不断，但你却找不到任何线索——日志里没有明显错误，服务器CPU和内存看起来也正常。这时候，如果你有完善的监控数据，可能会发现是数据库连接池耗尽，或者某个API的响应时间突然飙升。

有效的监控能帮我们实现：

• 问题预警：在用户发现之前识别潜在问题
• 故障排查：快速定位问题根源，减少故障恢复时间
• 性能优化：找到系统瓶颈，针对性地进行优化
• 容量规划：根据监控数据预测资源需求，合理扩容
• 业务分析：通过监控指标了解系统使用模式和业务增长

一个完整的监控体系通常包含三个部分：

• 指标（Metrics）：系统和业务的量化数据（如响应时间、错误率）
• 日志（Logs）：系统事件的记录
• 追踪（Traces）：请求的完整路径（分布式追踪）

本文重点将聚焦于指标监控，介绍如何使用Micrometer和Prometheus构建指标收集和分析系统。

二、Micrometer：Java指标收集的"瑞士军刀"

Micrometer是一个开源的指标收集库，它为各种提供了一套统一的API，可以对接将指标数据导出到各种监控系统（如Prometheus、Graphite、Datadog等）。它就像一个适配器，让你无需关心底层监控系统的差异，专注注于指标的定义和收集。

2.1 Micrometer的核心概念

• Meter：指标的抽象，代表一个可测量的值
• MeterRegistry：Meter的注册表，负责创建和管理Meter
• Metric：Meter在特定时间点的测量值
• Tag：键值对，用于对指标进行维度划分（如service=order-service、env=prod）

Micrometer支持多种类型的指标：

指标类型	用途	示例
Counter	单调递增的计数器	接口调用次数、错误数量
Gauge	可以增减的数值	队列长度、当前活跃用户数
Timer	测量短时间延迟和频率	接口响应时间、方法执行时间
Summary	记录数值的分布	请求大小的分布
Histogram	记录数值的分布（可配置分桶）	响应时间的分布
LongTaskTimer	测量长时间运行的任务	异步任务的执行时间

2.2 Spring Boot集成Micrometer

Spring Boot 2.x及以上版本默认集成了Micrometer，只需添加相关依赖即可快速使用。

2.2.1 添加依赖

<!-- Micrometer核心依赖 -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
</dependency>

<!-- Spring Boot Actuator，提供默认的指标端点 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

<!-- Prometheus导出器，用于将指标导出到Prometheus -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

2.2.2 配置Actuator

在application.yml中配置Actuator，暴露指标端点：

management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus  # 暴露prometheus端点
  metrics:
    tags:
      application: order-service  # 全局标签，所有指标都会带上这个标签
      environment: ${spring.profiles.active:default}  # 环境标签
  endpoint:
    health:
      show-details: always  # 显示健康检查详情

配置完成后，启动应用，访问http://localhost:8080/actuator/prometheus即可看到导出的指标数据。

2.3 使用Micrometer收集自定义指标

除了Spring Boot自动收集的系统指标，我们还可以定义自己的业务指标。

2.3.1 注入MeterRegistry

import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class OrderMetrics {
    private final MeterRegistry meterRegistry;
    
    // 构造函数注入MeterRegistry
    @Autowired
    public OrderMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    // 后续将在这里定义各种指标
}

2.3.2 定义Counter（计数器）

Counter用于记录单调递增的数值，如接口调用次数、错误数量等：

// 定义订单创建计数器
private final Counter orderCreatedCounter;
// 定义订单支付计数器
private final Counter orderPaidCounter;
// 定义订单创建错误计数器
private final Counter orderCreationErrorCounter;

public OrderMetrics(MeterRegistry meterRegistry) {
    this.meterRegistry = meterRegistry;
    
    // 初始化计数器
    this.orderCreatedCounter = Counter.builder("orders.created")
        .description("创建的订单总数")
        .register(meterRegistry);
        
    this.orderPaidCounter = Counter.builder("orders.paid")
        .description("已支付的订单总数")
        .register(meterRegistry);
        
    this.orderCreationErrorCounter = Counter.builder("orders.creation.errors")
        .description("创建订单时发生的错误总数")
        .register(meterRegistry);
}

// 使用计数器
public void onOrderCreated() {
    orderCreatedCounter.increment();
}

public void onOrderPaid() {
    orderPaidCounter.increment();
}

public void onOrderCreationError() {
    orderCreationErrorCounter.increment();
}

在业务代码中使用：

@Service
public class OrderService {
    private final OrderMetrics orderMetrics;
    
    @Autowired
    public OrderService(OrderMetrics orderMetrics) {
        this.orderMetrics = orderMetrics;
    }
    
    public Order createOrder(OrderRequest request) {
        try {
            // 创建订单的业务逻辑
            Order order = new Order();
            // ...
            
            orderMetrics.onOrderCreated();
            return order;
        } catch (Exception e) {
            orderMetrics.onOrderCreationError();
            throw e;
        }
    }
    
    public void payOrder(Long orderId) {
        // 支付逻辑
        // ...
        
        orderMetrics.onOrderPaid();
    }
}

2.3.3 定义Gauge（ gauge）

Gauge用于记录可以上下浮动的数值，如当前活跃用户数、队列长度等：

// 定义当前活跃订单数的Gauge
private final AtomicInteger activeOrders = new AtomicInteger(0);

public OrderMetrics(MeterRegistry meterRegistry) {
    // ... 其他指标初始化
    
    // 注册Gauge
    Gauge.builder("orders.active", activeOrders, AtomicInteger::get)
        .description("当前活跃的订单数")
        .register(meterRegistry);
}

// 更新Gauge值
public void incrementActiveOrders() {
    activeOrders.incrementAndGet();
}

public void decrementActiveOrders() {
    activeOrders.decrementAndGet();
}

在业务代码中使用：

public Order createOrder(OrderRequest request) {
    try {
        orderMetrics.incrementActiveOrders();
        
        // 创建订单逻辑
        // ...
        
        return order;
    } finally {
        orderMetrics.decrementActiveOrders();
    }
}

2.3.4 定义Timer（计时器）

Timer用于测量短时间操作的执行时间和频率，如接口响应时间、方法执行时间等：

// 定义订单创建时间的Timer
private final Timer orderCreationTimer;

public OrderMetrics(MeterRegistry meterRegistry) {
    // ... 其他指标初始化
    
    this.orderCreationTimer = Timer.builder("orders.creation.time")
        .description("订单创建所需的时间")
        .register(meterRegistry);
}

// 使用Timer的两种方式

// 方式1：使用record方法
public <T> T recordOrderCreationTime(Supplier<T> operation) {
    return orderCreationTimer.record(operation);
}

// 方式2：使用StopWatch
public Timer.Sample startOrderCreationTimer() {
    return Timer.start(meterRegistry);
}

在业务代码中使用：

// 方式1：使用record方法
public Order createOrder(OrderRequest request) {
    return orderMetrics.recordOrderCreationTime(() -> {
        // 创建订单的业务逻辑
        // ...
        return new Order();
    });
}

// 方式2：使用StopWatch
public Order createOrderWithStopWatch(OrderRequest request) {
    Timer.Sample sample = orderMetrics.startOrderCreationTimer();
    try {
        // 创建订单的业务逻辑
        // ...
        return new Order();
    } finally {
        sample.stop(orderMetrics.getOrderCreationTimer());
    }
}

2.3.5 使用注解简化指标收集

Micrometer提供了注解支持，可以通过注解快速添加指标：

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core-annotations</artifactId>
    <version>1.10.6</version>
</dependency>

使用注解：

import io.micrometer.core.annotation.Counted;
import io.micrometer.core.annotation.Timed;

@Service
public class PaymentService {
    
    // 记录方法调用次数和错误次数
    @Counted(value = "payments.processed", description = "处理的支付总数")
    public Payment processPayment(PaymentRequest request) {
        // 支付处理逻辑
        // ...
        return new Payment();
    }
    
    // 记录方法执行时间
    @Timed(value = "payments.processing.time", description = "支付处理时间")
    public Payment processPaymentWithTiming(PaymentRequest request) {
        // 支付处理逻辑
        // ...
        return new Payment();
    }
    
    // 结合标签使用
    @Timed(value = "refunds.processing.time", 
           description = "退款处理时间",
           extraTags = {"paymentType", "${request.paymentType}"})
    public Refund processRefund(RefundRequest request) {
        // 退款处理逻辑
        // ...
        return new Refund();
    }
}

需要注意的是，注解方式需要额外配置AOP支持才能生效：

@Configuration
@EnableAspectJAutoProxy
public class MetricsConfig {
    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) {
        return new TimedAspect(registry);
    }
    
    @Bean
    public CountedAspect countedAspect(MeterRegistry registry) {
        return new CountedAspect(registry);
    }
}

2.4 指标标签（Tag）的最佳实践

标签是Micrometer中非常强大的功能，它允许我们从多个维度分析指标。但如果使用不当，可能会导致指标数量爆炸，影响系统性能。

最佳实践：

1. 使用有限基数的标签：标签值的数量应该是有限的（如环境、服务名、错误类型），避免使用用户ID、订单号等高基数标签。

2. 定义全局标签：对于所有指标都需要的标签（如应用名、环境），可以配置为全局标签：

management:
  metrics:
    tags:
      application: ${spring.application.name}
      environment: ${spring.profiles.active:unknown}
      version: ${app.version:unknown}

3. 使用动态标签：对于需要根据方法参数动态变化的标签，可以这样使用：

public void processOrder(Order order) {
    Timer.builder("orders.processing.time")
        .tag("orderType", order.getType())
        .tag("status", order.getStatus())
        .register(meterRegistry)
        .record(() -> {
            // 处理订单的逻辑
        });
}

4. 避免标签值为空或null：确保标签值有意义，避免使用空字符串或null作为标签值。

三、Prometheus：指标存储与查询的利器

Prometheus是一个开源的系统监控和告警工具包，由SoundCloud开发，后来成为CNCF（Cloud Native Computing Foundation）的毕业项目。它特别适合监控容器化环境和微服务架构。

3.1 Prometheus的核心特性

• 多维数据模型：使用键值对（指标名+标签）来标识时间序列数据
• 灵活的查询语言：PromQL，用于查询和分析指标数据
• 本地时序数据库：自带时序数据库，也支持集成外部存储
• 基于HTTP的拉取模型：通过HTTP接口主动拉取指标数据
• 推送网关：用于支持短生命周期的任务推送指标
• 服务发现：自动发现需要监控的目标
• 丰富的可视化：集成Grafana等可视化工具
• 告警管理：基于PromQL定义告警规则

3.2 安装和启动Prometheus

3.2.1 二进制安装（推荐）

# 下载最新版本（请根据实际情况替换版本号）
wget https://github.com/prometheus/prometheus/releases/download/v2.45.0/prometheus-2.45.0.linux-amd64.tar.gz

# 解压
tar xvfz prometheus-2.45.0.linux-amd64.tar.gz
cd prometheus-2.45.0.linux-amd64

# 查看版本
./prometheus --version

3.2.2 Docker安装

docker run -d \
  -p 9090:9090 \
  -v /path/to/prometheus.yml:/etc/prometheus/prometheus.yml \
  prom/prometheus

3.2.3 配置Prometheus

创建或编辑prometheus.yml配置文件：

global:
  scrape_interval: 15s  # 全局拉取间隔，默认15秒
  evaluation_interval: 15s  # 规则评估间隔，默认15秒

rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

scrape_configs:
  # 监控Prometheus自身
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  
  # 监控Java应用（Order Service）
  - job_name: 'order-service'
    metrics_path: '/actuator/prometheus'  # Micrometer暴露的指标路径
    scrape_interval: 5s  # 更频繁地拉取订单服务的指标
    static_configs:
      - targets: ['localhost:8080']  # 订单服务的地址
  
  # 监控另一个Java应用（Payment Service）
  - job_name: 'payment-service'
    metrics_path: '/actuator/prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['localhost:8081']  # 支付服务的地址

3.2.4 启动Prometheus

# 二进制方式启动
./prometheus --config.file=prometheus.yml

# Docker方式启动（如果还没启动）
docker run -d -p 9090:9090 -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus

启动后，访问http://localhost:9090即可打开Prometheus的Web界面。

3.3 服务发现配置

在实际生产环境中，服务实例可能会动态变化（扩缩容、故障转移等），手动配置targets不现实。Prometheus支持多种服务发现机制：

3.3.1 基于Consul的服务发现

如果你的服务注册在Consul上，可以这样配置：

scrape_configs:
  - job_name: 'consul-services'
    metrics_path: '/actuator/prometheus'
    consul_sd_configs:
      - server: 'localhost:8500'  # Consul服务器地址
        services: []  # 空表示发现所有服务
    
    # 为不同服务设置不同的标签
    relabel_configs:
      - source_labels: [__meta_consul_service]
        action: replace
        target_label: service

3.3.2 基于Kubernetes的服务发现

在Kubernetes环境中，可以使用K8s的服务发现：

scrape_configs:
  - job_name: 'kubernetes-services'
    kubernetes_sd_configs:
      - role: endpoints
    relabel_configs:
      - source_labels: [__meta_kubernetes_service_label_app]
        action: keep
        regex: .+  # 保留所有有app标签的服务
      - source_labels: [__meta_kubernetes_namespace]
        action: replace
        target_label: kubernetes_namespace
      - source_labels: [__meta_kubernetes_service_name]
        action: replace
        target_label: kubernetes_name

3.4 PromQL入门：查询指标数据

PromQL是Prometheus的查询语言，用于从时间序列数据库中查询指标数据。

3.4.1 基本查询

# 查询订单创建总数
orders_created_total

# 带标签的查询：查询生产环境的订单创建总数
orders_created_total{environment="prod"}

# 使用正则表达式匹配标签：查询prod或test环境的订单创建总数
orders_created_total{environment=~"prod|test"}

# 排除特定标签：排除payment-type为credit_card的订单
orders_created_total{payment_type!="credit_card"}

3.4.2 范围查询

# 查询过去5分钟的订单创建总数
orders_created_total[5m]

# 查询过去1小时，每1分钟的订单创建数
rate(orders_created_total[1m])[1h:]

3.4.3 常用函数

# 计算订单创建的增长率（每秒）
rate(orders_created_total[5m])

# 计算5分钟内的平均响应时间
avg(orders_creation_time_seconds_sum{service="order-service"} / orders_creation_time_seconds_count{service="order-service"})

# 计算95%的响应时间
histogram_quantile(0.95, sum(rate(orders_creation_time_seconds_bucket[5m])) by (le, service))

# 计算错误率
sum(rate(orders_creation_errors_total[5m])) / sum(rate(orders_created_total[5m]))

3.4.4 聚合操作

# 按服务汇总请求数
sum(rate(http_requests_total[5m])) by (service)

# 计算每个服务的平均响应时间
avg(http_request_duration_seconds_sum / http_request_duration_seconds_count) by (service)

# 找出响应时间最长的3个接口
topk(3, avg(http_request_duration_seconds_sum / http_request_duration_seconds_count) by (endpoint))

四、Grafana：数据可视化的"魔法工具"

Prometheus提供了基本的图表功能，但在可视化方面，Grafana才是专业的选择。Grafana是一个开源的数据可视化和监控平台，支持多种数据源（包括Prometheus），可以创建精美的仪表盘。

4.1 安装和启动Grafana

4.1.1 二进制安装

# 下载最新版本（请根据实际情况替换版本号）
wget https://dl.grafana.com/oss/release/grafana-10.0.3.linux-amd64.tar.gz

# 解压
tar -zxvf grafana-10.0.3.linux-amd64.tar.gz
cd grafana-10.0.3

# 启动
./bin/grafana-server

4.1.2 Docker安装

docker run -d -p 3000:3000 --name grafana grafana/grafana

启动后，访问http://localhost:3000，默认用户名/密码为admin/admin。

4.2 配置Prometheus数据源

1. 登录Grafana后，点击左侧菜单的"Configuration" -> “Data Sources”
2. 点击"Add data source"，选择"Prometheus"
3. 在"HTTP"部分，设置"URL"为Prometheus的地址（如http://localhost:9090）
4. 点击"Save & Test"，确认连接成功

4.3 创建自定义仪表盘

创建一个新的仪表盘，添加面板来展示我们关心的指标：

1. 点击"+" -> "Dashboard"创建新仪表盘
2. 点击"Add panel"添加面板
3. 在查询编辑器中输入PromQL查询，例如：

# 订单创建总数
orders_created_total

# 订单创建速率
rate(orders_created_total[5m])

# 订单创建错误率
rate(orders_creation_errors_total[5m]) / rate(orders_created_total[5m])

# 订单创建响应时间（平均）
orders_creation_time_seconds_sum / orders_creation_time_seconds_count

# 订单创建响应时间（95分位）
histogram_quantile(0.95, sum(rate(orders_creation_time_seconds_bucket[5m])) by (le))

4. 调整面板的标题、类型（图表、 gauge等）和样式
5. 保存仪表盘

4.4 使用社区仪表盘

Grafana社区提供了许多现成的仪表盘模板，可以直接导入使用：

1. 访问Grafana Dashboards
2. 搜索适合Java应用的仪表盘，如"Spring Boot 2.1 Statistics"（ID: 10280）
3. 在Grafana中点击"+" -> “Import”，输入仪表盘ID
4. 选择Prometheus数据源，点击"Import"

这些现成的仪表盘通常包含了Java应用常见的监控指标：JVM内存使用、GC情况、线程数、HTTP请求等。

4.5 设置告警

Grafana可以基于指标设置告警：

1. 在面板上点击"Edit"进入编辑模式
2. 切换到"Alert"标签页
3. 点击"Create Alert"创建告警规则
4. 设置告警条件，例如：
   • 错误率超过5%
   • 平均响应时间超过1秒
   • JVM堆内存使用率超过90%
5. 配置通知渠道（邮件、Slack、PagerDuty等）
6. 保存告警规则

五、监控Java应用的关键指标

监控Java应用时，我们需要关注以下几类关键指标：

5.1 系统指标

• CPU使用率：系统和进程的CPU使用率
• 内存使用率：系统内存和JVM内存的使用情况
• 磁盘I/O：磁盘读写速率和使用率
• 网络I/O：网络吞吐量和连接数

相关PromQL查询：

# 系统CPU使用率
100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# JVM堆内存使用率
(sum(jvm_memory_used_bytes{area="heap"}) / sum(jvm_memory_max_bytes{area="heap"})) * 100

# 磁盘使用率
100 - (node_filesystem_free_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"} * 100)

# 网络接收速率
rate(node_network_receive_bytes_total[5m])

5.2 JVM指标

• 内存使用：堆内存、非堆内存的使用情况
• 垃圾回收：GC次数、GC耗时、GC暂停时间
• 线程状态：活跃线程数、阻塞线程数、等待线程数
• 类加载：加载的类数量、卸载的类数量

相关PromQL查询：

# 堆内存使用
jvm_memory_used_bytes{area="heap"}

# 非堆内存使用
jvm_memory_used_bytes{area="nonheap"}

# GC次数
sum(rate(jvm_gc_collection_seconds_count[5m])) by (gc)

# GC耗时
sum(rate(jvm_gc_collection_seconds_sum[5m])) by (gc)

# 活跃线程数
jvm_threads_states_threads{state="runnable"}

# 阻塞线程数
jvm_threads_states_threads{state="blocked"}

5.3 应用指标

• 接口响应时间：平均响应时间、P95/P99响应时间
• 接口调用次数：总调用次数、每秒调用次数
• 错误率：接口调用的错误比例
• 业务指标：订单数、支付金额、用户注册数等

相关PromQL查询：

# HTTP请求数
rate(http_server_requests_seconds_count[5m])

# HTTP平均响应时间
sum(rate(http_server_requests_seconds_sum[5m])) / sum(rate(http_server_requests_seconds_count[5m]))

# HTTP 95分位响应时间
histogram_quantile(0.95, sum(rate(http_server_requests_seconds_bucket[5m])) by (le, uri))

# HTTP错误率（5xx状态码）
sum(rate(http_server_requests_seconds_count{status=~"5.."}[5m])) / sum(rate(http_server_requests_seconds_count[5m]))

# 订单创建速率
rate(orders_created_total[5m])

5.4 数据库指标

• 连接池状态：活跃连接数、空闲连接数、等待连接数
• 查询性能：SQL查询次数、查询响应时间
• 事务指标：事务数量、提交/回滚比例

相关PromQL查询（以HikariCP连接池为例）：

# 活跃连接数
hikaricp_connections_active

# 空闲连接数
hikaricp_connections_idle

# 连接等待数
hikaricp_connections_pending

# JDBC查询次数
rate(jdbc_connections_query_seconds_count[5m])

# JDBC查询响应时间
sum(rate(jdbc_connections_query_seconds_sum[5m])) / sum(rate(jdbc_connections_query_seconds_count[5m]))

六、最佳实践与性能优化

6.1 指标设计原则

• KISS原则：Keep It Simple, Stupid。只收集必要的指标，避免指标泛滥。
• 可聚合性：设计指标时考虑是否可以按不同维度聚合分析。
• 一致性：保持指标命名和标签的一致性，方便跨服务分析。
• 业务相关性：除了技术指标，也要收集与业务相关的指标。

指标命名建议：

<what>_<unit>
# 例如：
orders_created_total
http_requests_seconds
jvm_memory_used_bytes

6.2 性能优化

监控系统本身也会消耗资源，需要进行适当优化：

• 调整采样频率：非关键指标可以降低采样频率（如从5秒调整为30秒）。
• 控制标签基数：避免高基数标签，限制每个指标的时间序列数量。
• 使用直方图分桶：合理设置直方图的分桶（bucket），避免过多分桶。
• 数据保留策略：设置合理的数据保留时间，避免存储过多历史数据。

Prometheus数据保留配置：

storage:
  retention: 15d  # 保留15天数据
  retention_size: 100GB  # 最大存储100GB

6.3 监控告警策略

• 多维度告警：结合多个指标设置告警，避免单一指标告警导致误报。
• 分级告警：根据严重程度设置不同级别的告警（警告、严重、紧急）。
• 告警聚合：对同一类告警进行聚合，避免告警风暴。
• 告警抑制：当高级别告警触发时，抑制相关的低级别告警。

一个合理的告警规则示例：

groups:
- name: order-service-alerts
  rules:
  - alert: HighErrorRate
    expr: sum(rate(orders_creation_errors_total[5m])) / sum(rate(orders_created_total[5m])) > 0.05
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "订单服务错误率过高"
      description: "订单服务错误率超过5%已持续2分钟 (当前值: {{ $value }})"
      
  - alert: SlowResponseTime
    expr: histogram_quantile(0.95, sum(rate(orders_creation_time_seconds_bucket[5m])) by (le)) > 1
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "订单服务响应时间过长"
      description: "订单服务95%响应时间超过1秒已持续5分钟"
      
  - alert: HighMemoryUsage
    expr: (sum(jvm_memory_used_bytes{area="heap"}) / sum(jvm_memory_max_bytes{area="heap"})) * 100 > 90
    for: 10m
    labels:
      severity: warning
    annotations:
      summary: "JVM堆内存使用率过高"
      description: "JVM堆内存使用率超过90%已持续10分钟"

6.4 监控体系的演进

一个完善的监控体系不是一蹴而就的，而是逐步演进的：

1. 基础监控阶段：监控系统指标和JVM指标，确保服务存活。
2. 应用监控阶段：添加接口响应时间、错误率等应用指标。
3. 业务监控阶段：引入业务指标，如订单量、支付金额等。
4. 智能监控阶段：结合AI和机器学习，实现异常检测和预测。

七、总结：构建全方位的Java服务监控体系

通过本文的介绍，我们了解了如何使用Micrometer、Prometheus和Grafana构建Java服务的监控体系：

• Micrometer：作为指标收集的统一接口，帮助我们在Java应用中定义和收集各种指标。
• Prometheus：负责指标的存储和查询，通过PromQL可以灵活地分析指标数据。
• Grafana：提供强大的数据可视化功能，让我们可以创建直观的监控仪表盘和告警。

一个好的监控体系应该是：

• 全面的：覆盖系统、JVM、应用和业务各个层面。
• 实时的：能够及时反映系统的当前状态。
• 可预警的：在问题影响用户之前发出告警。
• 可分析的：提供足够的数据帮助定位问题根源。

记住，监控不是目的，而是手段。最终目标是通过监控提高系统的可靠性和可用性，为用户提供更好的服务。

随着微服务架构的普及和云原生技术的发展，监控的重要性将愈发凸显。希望本文能帮助你构建更完善的Java服务监控体系，让你的服务运行得更加稳定可靠。