package com.example.otel;

import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.baggage.propagation.W3CBaggagePropagator;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporter;
import io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporter;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor;
import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
import io.opentelemetry.sdk.trace.samplers.Sampler;
import java.time.Duration;

public final class OpenTelemetryConfig {

    public static OpenTelemetry init() {
        String endpoint = System.getenv().getOrDefault(
                "OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317");

        Resource resource = Resource.getDefault().toBuilder()
                .put(AttributeKey.stringKey("service.name"), "order-service")
                .put(AttributeKey.stringKey("service.version"), "1.2.0")
                .put(AttributeKey.stringKey("deployment.environment.name"), "prod")
                .build();

        OtlpGrpcSpanExporter spanExporter = OtlpGrpcSpanExporter.builder()
                .setEndpoint(endpoint)
                .setTimeout(Duration.ofSeconds(10))
                .build();

        SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
                .setResource(resource)
                .setSampler(Sampler.parentBased(Sampler.traceIdRatioBased(0.1)))
                .addSpanProcessor(BatchSpanProcessor.builder(spanExporter)
                        .setScheduleDelay(Duration.ofSeconds(5))
                        .setMaxQueueSize(2048)
                        .setMaxExportBatchSize(512)
                        .build())
                .build();

        SdkMeterProvider meterProvider = SdkMeterProvider.builder()
                .setResource(resource)
                .registerMetricReader(PeriodicMetricReader.builder(
                                OtlpGrpcMetricExporter.builder()
                                        .setEndpoint(endpoint)
                                        .setTimeout(Duration.ofSeconds(10))
                                        .build())
                        .setInterval(Duration.ofSeconds(15))
                        .build())
                .build();

        SdkLoggerProvider loggerProvider = SdkLoggerProvider.builder()
                .setResource(resource)
                .addLogRecordProcessor(BatchLogRecordProcessor.builder(
                                OtlpGrpcLogRecordExporter.builder()
                                        .setEndpoint(endpoint)
                                        .setTimeout(Duration.ofSeconds(10))
                                        .build())
                        .setScheduleDelay(Duration.ofSeconds(5))
                        .build())
                .build();

        ContextPropagators propagators = ContextPropagators.create(
                TextMapPropagator.composite(
                        W3CTraceContextPropagator.getInstance(),
                        W3CBaggagePropagator.getInstance()));

        OpenTelemetrySdk sdk = OpenTelemetrySdk.builder()
                .setTracerProvider(tracerProvider)
                .setMeterProvider(meterProvider)
                .setLoggerProvider(loggerProvider)
                .setPropagators(propagators)
                .build();

        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            tracerProvider.shutdown();
            meterProvider.shutdown();
            loggerProvider.shutdown();
        }));
        return sdk;
    }
}

import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;

OpenTelemetry openTelemetry = AutoConfiguredOpenTelemetrySdk.initialize()
        .getOpenTelemetrySdk();

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.OpenTelemetry;

OpenTelemetry openTelemetry =
        GlobalOpenTelemetry.isSet() ? GlobalOpenTelemetry.get() : OpenTelemetryConfig.init();

import io.opentelemetry.api.trace.Tracer;

Tracer tracer = openTelemetry.getTracer("com.example.order", "1.0.0");

import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.SpanKind;
import io.opentelemetry.api.trace.StatusCode;
import io.opentelemetry.context.Scope;

public Order createOrder(OrderRequest request) {
    Span span = tracer.spanBuilder("order.create")
            .setSpanKind(SpanKind.INTERNAL)
            .setAttribute(AttributeKey.stringKey("order.channel"), request.channel())
            .setAttribute(AttributeKey.longKey("order.item.count"), request.items().size())
            .startSpan();

    try (Scope ignored = span.makeCurrent()) {
        Order order = doCreateOrder(request);
        span.setAttribute("order.id", order.id());
        span.setStatus(StatusCode.OK);
        return order;
    } catch (Exception e) {
        span.recordException(e);
        span.setStatus(StatusCode.ERROR, e.getMessage());
        throw e;
    } finally {
        span.end();
    }
}

Span parent = tracer.spanBuilder("order.create").startSpan();
try (Scope scope = parent.makeCurrent()) {
    Span child = tracer.spanBuilder("inventory.reserve").startSpan();
    try (Scope childScope = child.makeCurrent()) {
        // 业务逻辑
    } finally {
        child.end();
    }
} finally {
    parent.end();
}

span.addEvent("cache.miss", Attributes.of(
        AttributeKey.stringKey("cache.name"), "order-cache",
        AttributeKey.stringKey("cache.key"), orderId));

Context producerContext = ...; // 从消息头 extract 得到的 Context
SpanContext linkContext = Span.fromContext(producerContext).getSpanContext();

Span consumer = tracer.spanBuilder("order.consume")
        .setSpanKind(SpanKind.CONSUMER)
        .addLink(linkContext)
        .startSpan();

import io.opentelemetry.context.Context;
import io.opentelemetry.context.propagation.TextMapSetter;
import java.net.http.HttpRequest;

TextMapSetter<HttpRequest.Builder> setter =
        (carrier, key, value) -> carrier.header(key, value);

HttpRequest.Builder builder = HttpRequest.newBuilder()
        .uri(URI.create("http://inventory-service/reserve"))
        .GET();

openTelemetry.getPropagators()
        .getTextMapPropagator()
        .inject(Context.current(), builder, setter);

import io.opentelemetry.context.propagation.TextMapGetter;
import io.opentelemetry.context.Scope;

TextMapGetter<HttpHeaders> getter = new TextMapGetter<>() {
    @Override
    public Iterable<String> keys(HttpHeaders carrier) {
        return carrier.names();
    }

    @Override
    public String get(HttpHeaders carrier, String key) {
        return carrier.firstValue(key).orElse(null);
    }
};

Context extracted = openTelemetry.getPropagators()
        .getTextMapPropagator()
        .extract(Context.current(), headers, getter);

try (Scope scope = extracted.makeCurrent()) {
    Span serverSpan = tracer.spanBuilder("http.server")
            .setSpanKind(SpanKind.SERVER)
            .startSpan();
    try (Scope serverScope = serverSpan.makeCurrent()) {
        // 处理请求
    } finally {
        serverSpan.end();
    }
}

Context context = Context.current();

executor.submit(context.wrap(() -> {
    Span asyncSpan = tracer.spanBuilder("order.async").startSpan();
    try (Scope scope = asyncSpan.makeCurrent()) {
        // 异步任务
    } finally {
        asyncSpan.end();
    }
}));

import io.opentelemetry.api.metrics.Meter;

Meter meter = openTelemetry.getMeter("com.example.order");

import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.metrics.LongCounter;

LongCounter ordersCreated = meter.counterBuilder("orders.created")
        .setDescription("Number of created orders")
        .setUnit("{order}")
        .build();

ordersCreated.add(1, Attributes.of(
        AttributeKey.stringKey("channel"), "web",
        AttributeKey.stringKey("result"), "success"));

import io.opentelemetry.api.metrics.DoubleHistogram;

DoubleHistogram orderDuration = meter.histogramBuilder("order.process.duration")
        .setDescription("Order processing duration")
        .setUnit("s")
        .build();

long start = System.nanoTime();
try {
    // 业务逻辑
} finally {
    double seconds = (System.nanoTime() - start) / 1_000_000_000.0;
    orderDuration.record(seconds, Attributes.of(
            AttributeKey.stringKey("channel"), "web"));
}

meter.gaugeBuilder("queue.depth")
        .setDescription("Current queue depth")
        .setUnit("{item}")
        .buildWithCallback(observable -> observable.record(queue.size()));

LongUpDownCounter inFlight = meter.upDownCounterBuilder("orders.inflight").build();
inFlight.add(1);
try {
    // 处理
} finally {
    inFlight.add(-1);
}

ordersCreated.add(1, Attributes.of(
        AttributeKey.stringKey("channel"), "web",
        AttributeKey.stringKey("result"), "success"));

import io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender;
import io.opentelemetry.sdk.OpenTelemetrySdk;

OpenTelemetrySdk sdk = (OpenTelemetrySdk) OpenTelemetryConfig.init();
OpenTelemetryAppender.install(sdk);

Span span = tracer.spanBuilder("operation").startSpan();
try (Scope scope = span.makeCurrent()) {
    // 这里的 Span.current() 是 span
} finally {
    span.end();
}

import io.opentelemetry.api.baggage.Baggage;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.Scope;

Baggage baggage = Baggage.current().toBuilder()
        .put("tenant.id", tenantId)
        .put("request.channel", "web")
        .build();

try (Scope scope = Context.current().with(baggage).makeCurrent()) {
    // 下游 HTTP 调用会自动传播 baggage
}

String tenantId = Baggage.current().getEntryValue("tenant.id");

Context context = Context.current();

executor.submit(context.wrap(() -> {
    // 这里可以访问父 Span 和 Baggage
}));

.setSampler(Sampler.parentBased(Sampler.traceIdRatioBased(0.1)))

Resource resource = Resource.getDefault().toBuilder()
        .put(AttributeKey.stringKey("service.name"), "order-service")
        .put(AttributeKey.stringKey("service.version"), "1.2.0")
        .put(AttributeKey.stringKey("service.instance.id"), instanceId)
        .put(AttributeKey.stringKey("deployment.environment.name"), "prod")
        .build();

import static io.opentelemetry.semconv.SemanticAttributes.*;

span.setAttribute(HTTP_REQUEST_METHOD, "POST");
span.setAttribute(URL_PATH, "/orders");
span.setAttribute(HTTP_RESPONSE_STATUS_CODE, 200L);
span.setAttribute(SERVER_ADDRESS, "order-service");

import io.opentelemetry.instrumentation.annotations.SpanAttribute;
import io.opentelemetry.instrumentation.annotations.WithSpan;

@Service
public class OrderService {

    @WithSpan("order.create")
    public Order create(@SpanAttribute("order.channel") String channel,
                        @SpanAttribute("order.item.count") int itemCount) {
        // 业务逻辑
        return order;
    }
}

openTelemetry.getPropagators()
        .getTextMapPropagator()
        .inject(Context.current(), request, setter);

executor.submit(Context.current().wrap(() -> {
    // 保留父 Span
}));

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;

import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;

class OrderServiceTest {

    @RegisterExtension
    static final OpenTelemetryExtension otel = OpenTelemetryExtension.create();

    @Test
    void createsOrderSpan() {
        Tracer tracer = GlobalOpenTelemetry.getTracer("test");
        // 调用被测代码，内部使用 GlobalOpenTelemetry
        // ...

        assertThat(otel.getSpans()).hasSize(1);
        assertThat(otel.getSpans().get(0))
                .hasName("order.create")
                .hasAttribute(AttributeKey.stringKey("order.channel"), "web");
    }
}

InMemorySpanExporter exporter = InMemorySpanExporter.create();
SdkTracerProvider provider = SdkTracerProvider.builder()
        .addSpanProcessor(SimpleSpanProcessor.create(exporter))
        .build();
OpenTelemetrySdk sdk = OpenTelemetrySdk.builder()
        .setTracerProvider(provider)
        .build();