#OpenTelemetry 统一标准

public class OtelConfig {

    public static OpenTelemetry initOpenTelemetry() {
        // 配置 OTLP 导出器
        OtlpGrpcSpanExporter spanExporter = OtlpGrpcSpanExporter.builder()
            .setEndpoint("http://otel-collector:4317")
            .build();

        // 配置日志导出器
        OtlpGrpcLogRecordExporter logExporter = OtlpGrpcLogRecordExporter.builder()
            .setEndpoint("http://otel-collector:4317")
            .build();

        // 配置指标导出器
        OtlpGrpcMetricExporter metricExporter = OtlpGrpcMetricExporter.builder()
            .setEndpoint("http://otel-collector:4317")
            .build();

        // 构建 SDK 实例
        return OpenTelemetrySdk.builder()
            .setTracerProvider(
                SdkTracerProvider.builder()
                    .addSpanProcessor(
                        BatchSpanProcessor.builder(spanExporter).build())
                    .build())
            .setMeterProvider(
                SdkMeterProvider.builder()
                    .registerMetricReader(
                        PeriodicMetricReader.builder(metricExporter)
                            .setInterval(Duration.ofSeconds(30))
                            .build())
                    .build())
            .setLoggerProvider(
                SdkLoggerProvider.builder()
                    .addLogRecordProcessor(
                        BatchLogRecordProcessor.builder(logExporter).build())
                    .build())
            .setResource(Resource.getDefault()
                .merge(Resource.create(Attributes.of(
                    ResourceAttributes.SERVICE_NAME, "order-service",
                    ResourceAttributes.SERVICE_VERSION, "v1.0.0",
                    ResourceAttributes.DEPLOYMENT_ENVIRONMENT, AttributeValue.stringAccessor(env)
                ))))
            .build();
    }
}

@Service
public class OrderServiceTracing {

    private final Tracer tracer;

    public OrderServiceTracing(OpenTelemetry openTelemetry) {
        this.tracer = openTelemetry.getTracer("order-service");
    }

    public Order placeOrder(OrderRequest request) {
        // 创建 Span，标记操作开始
        Span span = tracer.spanBuilder("placeOrder")
            .setAttribute("order.amount", request.getAmount())
            .setAttribute("order.itemCount", request.getItems().size())
            .startSpan();

        try (Scope scope = span.makeCurrent()) {
            // 执行业务逻辑
            validateOrder(request);

            PaymentResult payment = callPaymentService(request);

            if (payment.isSuccess()) {
                Order order = saveOrder(request);
                span.setAttribute("order.id", order.getId());
                span.setStatus(StatusCode.OK);
                return order;
            } else {
                // 标记 Span 为错误
                span.setStatus(StatusCode.ERROR, payment.getError());
                span.recordException(payment.getException());
                throw new OrderException(payment.getError());
            }
        } finally {
            // 确保 Span 结束
            span.end();
        }
    }

    private PaymentResult callPaymentService(OrderRequest request) {
        // 创建子 Span，记录支付调用的耗时
        Span paymentSpan = tracer.spanBuilder("PaymentService.call")
            .setAttribute("payment.method", request.getPaymentMethod())
            .startSpan();

        try (Scope scope = paymentSpan.makeCurrent()) {
            PaymentResult result = paymentClient.charge(request);
            paymentSpan.setAttribute("payment.transactionId", result.getTransactionId());
            return result;
        } finally {
            paymentSpan.end();
        }
    }
}

@Service
public class MetricsService {

    private final Meter meter;

    // 计数器：请求总数
    private final LongCounter requestCounter;

    // 直方图：请求延迟
    private final DoubleHistogram requestLatency;

    // 仪表：当前活跃请求数
    private final LongUpDownCounter activeRequests;

    public MetricsService(Meter meter) {
        this.meter = meter;

        this.requestCounter = meter.counterBuilder("http_requests_total")
            .setDescription("HTTP 请求总数")
            .setUnit("1")
            .build();

        this.requestLatency = meter.histogramBuilder("http_request_duration_seconds")
            .setDescription("HTTP 请求延迟分布")
            .setUnit("s")
            .ofLongs()
            .build();

        this.activeRequests = meter.upDownCounterBuilder("http_active_requests")
            .setDescription("当前活跃的 HTTP 请求数")
            .setUnit("1")
            .build();
    }

    public void recordRequest(String method, int status, long durationMs) {
        // 标签：方法、状态码
        Attributes attrs = Attributes.of(
            AttributeKey.stringKey("http.method"), method,
            AttributeKey.longKey("http.status_code"), (long) status
        );

        requestCounter.add(1, attrs);
        requestLatency.record(durationMs, attrs);
    }

    public void incrementActiveRequests() {
        activeRequests.add(1);
    }

    public void decrementActiveRequests() {
        activeRequests.add(-1);
    }
}