Java应用中的可观测性：Metrics、Traces、Logs的统一采集与Context传递

Java应用中的可观测性：Metrics、Traces、Logs的统一采集与Context传递

大家好，今天我们来聊聊Java应用中的可观测性，重点关注Metrics、Traces、Logs这三个支柱的统一采集，以及如何在它们之间传递Context。可观测性对于理解和调试复杂分布式系统至关重要。它不仅仅是监控，而是提供足够的信息，让你能够理解你的系统为什么会这样运行，并快速诊断问题。

1. 可观测性的三大支柱：Metrics, Traces, Logs

在深入代码之前，让我们先回顾一下可观测性的三个关键概念：

• Metrics (指标): 数值型数据，代表系统在一段时间内的度量。例如，CPU利用率、内存使用率、请求延迟、错误率等等。Metrics通常以聚合形式存在，例如平均值、最大值、百分位数等。
• Traces (链路追踪): 记录单个请求从开始到结束所经过的所有服务和组件的完整路径。它能帮助你理解请求在不同服务之间的调用关系和延迟分布，找出性能瓶颈。
• Logs (日志): 文本形式的事件记录，包含关于系统行为的详细信息。Logs可以用于诊断问题、审计活动和了解系统状态。

下表总结了这三个支柱的特点：

特征	Metrics	Traces	Logs
数据类型	数值型	结构化/非结构化	文本
目的	性能监控, 资源利用率	请求链路分析, 性能诊断	问题诊断, 审计, 历史记录
数据量	通常较小，聚合后的数据	中等，每个请求一条Trace	较大，事件记录数量多
数据结构	时序数据	树状结构	非结构化或半结构化
存储	时序数据库 (TSDB)	分布式追踪系统	日志管理系统 (ELK, Splunk)
分析	聚合, 趋势分析	延迟分析, 调用链分析	搜索, 过滤, 关联分析

2. 统一采集：选择合适的工具和框架

实现可观测性的第一步是采集数据。对于Java应用，有很多优秀的工具和框架可供选择。这里我们主要介绍 Micrometer, OpenTelemetry 和 SLF4J。

• Micrometer: 一个Java的度量工具库，它提供了一个通用的接口，可以与各种监控系统集成，例如 Prometheus, Graphite, Datadog, InfluxDB 等。 你可以通过 Micrometer 采集各种JVM指标、应用自定义指标等。
• OpenTelemetry: 一个 CNCF 项目，旨在提供一个统一的、vendor-neutral 的可观测性标准。它定义了 Metrics, Traces, Logs 的数据格式和 API，并提供了各种语言的 SDK。 OpenTelemetry的目标是取代各种专有的可观测性解决方案，实现数据的统一采集、传输和分析。
• SLF4J (Simple Logging Facade for Java): 一个日志抽象层，允许你在不修改代码的情况下切换不同的日志框架，例如 Logback, Log4j2 等。 SLF4J 使得你的应用更容易适应不同的部署环境和日志需求。

2.1 使用 Micrometer 采集 Metrics

首先，在你的项目中添加 Micrometer 和你选择的监控系统的依赖。 例如，使用Maven：

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
    <version>1.12.3</version>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
    <version>1.12.3</version>
</dependency>

然后，在你的代码中使用 MeterRegistry 来创建和记录指标。

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import io.micrometer.core.instrument.binder.jvm.JvmMemoryMetrics;
import io.micrometer.core.instrument.binder.system.ProcessorMetrics;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;

import java.time.Duration;
import java.util.Random;
import java.util.concurrent.TimeUnit;

public class MetricsExample {

    private static final Random random = new Random();

    public static void main(String[] args) throws InterruptedException {
        // 创建 MeterRegistry
        MeterRegistry registry = new SimpleMeterRegistry();

        // 绑定 JVM 和系统指标
        new JvmMemoryMetrics().bindTo(registry);
        new ProcessorMetrics().bindTo(registry);

        // 创建计数器
        Counter requestCounter = Counter.builder("my_app.requests")
                .description("Number of requests received")
                .tags("type", "http")
                .register(registry);

        // 创建计时器
        Timer requestTimer = Timer.builder("my_app.request_duration")
                .description("Duration of requests")
                .tags("type", "http")
                .register(registry);

        // 模拟请求处理
        for (int i = 0; i < 10; i++) {
            requestCounter.increment();

            long startTime = System.nanoTime();
            simulateRequestProcessing();
            long endTime = System.nanoTime();

            requestTimer.record(Duration.ofNanos(endTime - startTime));

            TimeUnit.SECONDS.sleep(1);
        }

        // 输出指标 (仅用于 SimpleMeterRegistry 示例)
        System.out.println(registry.getMetersAsString());
    }

    private static void simulateRequestProcessing() throws InterruptedException {
        // 模拟请求处理时间
        TimeUnit.MILLISECONDS.sleep(random.nextInt(500));
    }
}

在这个例子中，我们创建了一个计数器 requestCounter 和一个计时器 requestTimer。每次收到请求时，我们都会增加计数器的值，并记录请求的处理时间。 JvmMemoryMetrics 和 ProcessorMetrics 自动收集JVM和系统的相关指标。 SimpleMeterRegistry 是一个简单的内存型注册器，仅用于演示目的。在生产环境中，你应该使用适合你的监控系统的注册器，例如 PrometheusMeterRegistry。

2.2 使用 OpenTelemetry 采集 Traces

要使用 OpenTelemetry 采集 Traces，你需要添加 OpenTelemetry SDK 的依赖。 例如，使用Maven：

<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-sdk</artifactId>
    <version>1.35.0</version>
</dependency>
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-jaeger</artifactId>
    <version>1.35.0</version>
</dependency>

然后，你需要配置 OpenTelemetry SDK，并创建 Tracer 来创建和管理 Span。

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.exporter.jaeger.JaegerGrpcSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;

import java.util.Random;
import java.util.concurrent.TimeUnit;

public class TracesExample {

    private static final Random random = new Random();

    public static void main(String[] args) throws InterruptedException {
        // 配置 OpenTelemetry SDK
        OpenTelemetry openTelemetry = initializeOpenTelemetry();
        Tracer tracer = openTelemetry.getTracer("my-app", "1.0.0");

        // 模拟请求处理
        for (int i = 0; i < 3; i++) {
            // 创建 Span
            Span span = tracer.spanBuilder("processRequest").startSpan();
            span.setAttribute("request.id", i);

            try {
                simulateRequestProcessing(tracer, span);
            } finally {
                // 结束 Span
                span.end();
            }

            TimeUnit.SECONDS.sleep(1);
        }

        // 确保所有 Span 都被导出
        TimeUnit.SECONDS.sleep(2);
    }

    private static void simulateRequestProcessing(Tracer tracer, Span parentSpan) throws InterruptedException {
        // 创建子 Span
        Span childSpan = tracer.spanBuilder("doSomeWork")
                .setParent(io.opentelemetry.context.Context.current().with(parentSpan))
                .startSpan();
        try {
            TimeUnit.MILLISECONDS.sleep(random.nextInt(200));
            childSpan.addEvent("Doing some work");
        } finally {
            childSpan.end();
        }

        // 模拟数据库调用
        Span dbSpan = tracer.spanBuilder("databaseCall")
                .setParent(io.opentelemetry.context.Context.current().with(parentSpan))
                .startSpan();
        try {
            TimeUnit.MILLISECONDS.sleep(random.nextInt(300));
            dbSpan.setAttribute("db.statement", "SELECT * FROM users");
        } finally {
            dbSpan.end();
        }
    }

    private static OpenTelemetry initializeOpenTelemetry() {
        // 配置 Jaeger Exporter
        JaegerGrpcSpanExporter jaegerExporter = JaegerGrpcSpanExporter.builder()
                .setEndpoint("grpc://localhost:14250") // 替换为你的 Jaeger gRPC 地址
                .build();

        // 创建 SdkTracerProvider
        SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder()
                .addSpanProcessor(SimpleSpanProcessor.create(jaegerExporter))
                .build();

        // 创建 OpenTelemetrySdk
        OpenTelemetrySdk openTelemetrySdk = OpenTelemetrySdk.builder()
                .setTracerProvider(sdkTracerProvider)
                .buildAndRegisterGlobal();

        return openTelemetrySdk;
    }
}

在这个例子中，我们使用 Jaeger 作为 Trace 后端。 initializeOpenTelemetry 方法配置了 OpenTelemetry SDK，并将 Span 导出到 Jaeger。 Tracer 用于创建 Span，每个 Span 代表请求处理过程中的一个步骤。 setParent 方法用于建立 Span 之间的父子关系，形成完整的Trace。

2.3 使用 SLF4J 采集 Logs

SLF4J 的使用非常简单。 首先，添加 SLF4J API 的依赖。 例如，使用Maven：

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.12</version>
</dependency>

然后，你需要选择一个日志框架，例如 Logback 或 Log4j2，并添加相应的依赖。 例如，使用 Logback：

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.5.3</version>
    <scope>runtime</scope>
</dependency>

最后，在你的代码中使用 Logger 来记录日志。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogsExample {

    private static final Logger logger = LoggerFactory.getLogger(LogsExample.class);

    public static void main(String[] args) {
        logger.info("Application started");

        try {
            int result = 10 / 0; // 模拟异常
        } catch (ArithmeticException e) {
            logger.error("An error occurred", e);
        }

        logger.warn("Application is running low on resources");
        logger.debug("This is a debug message");
    }
}

在这个例子中，我们使用 LoggerFactory 获取 Logger 实例，并使用 info, error, warn, debug 等方法记录不同级别的日志。 SLF4J 会将日志委托给配置的日志框架 (例如 Logback) 进行处理。

3. Context 传递：关联 Metrics, Traces, Logs

仅仅采集 Metrics, Traces, Logs 还不够，我们需要将它们关联起来，才能进行更深入的分析。 Context 传递是实现关联的关键。

• Trace ID: 每个 Trace 都有一个唯一的 Trace ID，用于标识整个请求链路。
• Span ID: 每个 Span 都有一个唯一的 Span ID，用于标识请求链路中的一个步骤。
• Correlation ID: 一个自定义的 ID，用于关联不同的 Logs, Metrics 和 Traces。

3.1 使用 OpenTelemetry 进行 Context 传递

OpenTelemetry 提供了强大的 Context 传递机制。 你可以使用 Context 对象来携带 Trace ID 和 Span ID，并在不同的服务和组件之间传递。

import io.opentelemetry.api.trace.Span;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.Scope;

public class ContextExample {

    public static void main(String[] args) {
        // 获取当前 Span
        Span span = Span.current();

        // 创建一个新的 Context，并将 Span 设置为当前 Context
        try (Scope scope = span.makeCurrent()) {
            // 在这个代码块中，Span.current() 将返回 span 对象
            doSomething();
        }

        // 在这个代码块中，Span.current() 将返回 null 或之前的 Span
    }

    private static void doSomething() {
        // 获取当前 Span
        Span currentSpan = Span.current();

        // 记录日志
        System.out.println("Current Span ID: " + currentSpan.getSpanContext().getSpanId());
    }
}

在这个例子中，我们使用 span.makeCurrent() 创建一个 Scope 对象。 在 Scope 对象的作用域内，Span.current() 将返回 span 对象，从而可以在不同的方法和类之间传递 Span ID。

3.2 将 Trace ID 和 Span ID 添加到 Logs

为了将 Trace ID 和 Span ID 添加到 Logs，你需要配置你的日志框架。 以 Logback 为例，你可以在 logback.xml 文件中添加以下配置：

<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n traceId=[%X{traceId}] spanId=[%X{spanId}]</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

在这个配置中，我们使用了 %X{traceId} 和 %X{spanId} 来获取 MDC (Mapped Diagnostic Context) 中的 Trace ID 和 Span ID。 然后，你需要在你的代码中将 Trace ID 和 Span ID 放入 MDC 中。

import io.opentelemetry.api.trace.Span;
import org.slf4j.MDC;

public class LogCorrelationExample {

    public static void main(String[] args) {
        // 获取当前 Span
        Span span = Span.current();

        // 将 Trace ID 和 Span ID 放入 MDC 中
        MDC.put("traceId", span.getSpanContext().getTraceId());
        MDC.put("spanId", span.getSpanContext().getSpanId());

        try {
            // 记录日志
            System.out.println("This is a log message");
        } finally {
            // 清除 MDC
            MDC.remove("traceId");
            MDC.remove("spanId");
        }
    }
}

在这个例子中，我们使用 MDC.put() 将 Trace ID 和 Span ID 放入 MDC 中。 MDC.remove() 用于清除 MDC，防止 Context 泄露。 注意: 必须使用 try-finally 块来确保 MDC 在任何情况下都会被清除。

3.3 将 Trace ID 和 Span ID 添加到 Metrics

将 Trace ID 和 Span ID 添加到 Metrics 可以帮助你将 Metrics 与特定的请求链路关联起来。 你可以使用 Micrometer 的 Tag 来添加 Trace ID 和 Span ID。

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Tags;
import io.opentelemetry.api.trace.Span;

public class MetricsCorrelationExample {

    public static void main(String[] args) {
        // 创建 MeterRegistry
        MeterRegistry registry = new SimpleMeterRegistry(); // Replace with your registry

        // 获取当前 Span
        Span span = Span.current();

        // 创建计数器，并添加 Trace ID 和 Span ID 作为 Tag
        Counter requestCounter = Counter.builder("my_app.requests")
                .description("Number of requests received")
                .tags(Tags.of("traceId", span.getSpanContext().getTraceId(), "spanId", span.getSpanContext().getSpanId()))
                .register(registry);

        // 增加计数器
        requestCounter.increment();

        // 输出指标
        System.out.println(registry.getMetersAsString());
    }
}

在这个例子中，我们使用 Tags.of() 创建一个包含 Trace ID 和 Span ID 的 Tags 对象，并将其传递给 Counter.builder() 方法。

4. 总结：构建完整的可观测性体系

今天我们讨论了Java应用中的可观测性，重点介绍了 Metrics, Traces, Logs 的统一采集，以及如何在它们之间传递 Context。 使用 Micrometer 采集 Metrics，使用 OpenTelemetry 采集 Traces，使用 SLF4J 采集 Logs，并通过 Context 传递将它们关联起来。

通过建立完善的可观测性体系，你可以更好地理解你的系统，快速诊断问题，并优化性能。希望今天的分享对你有所帮助。 谢谢大家！