OpenTelemetry Tracing の使用

package org.acme.opentelemetry;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import org.jboss.logging.Logger;

@Path("/hello")
public class TracedResource {

    private static final Logger LOG = Logger.getLogger(TracedResource.class);

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        LOG.info("hello");
        return "hello";
    }
}

quarkus.application.name=myservice (1)
quarkus.otel.exporter.otlp.endpoint=http://localhost:4317 (2)
quarkus.otel.exporter.otlp.headers=authorization=Bearer my_secret (3)
quarkus.log.console.format=%d{HH:mm:ss} %-5p traceId=%X{traceId}, parentId=%X{parentId}, spanId=%X{spanId}, sampled=%X{sampled} [%c{2.}] (%t) %s%e%n  (4)

# Alternative to the console log
quarkus.http.access-log.pattern="...traceId=%{X,traceId} spanId=%{X,spanId}" (5)

quarkus.otel.exporter.otlp.endpoint=http://localhost:4317

quarkus.otel.exporter.otlp.traces.endpoint=http://trace-uri:4317 (1)
quarkus.otel.exporter.otlp.metrics.endpoint=http://metrics-uri:4317 (2)
quarkus.otel.exporter.otlp.logs.endpoint=http://logs-uri:4317 (3)

quarkus.otel.simple=true

docker run -it \
  -p 16686:16686 \
  -p 4317:4317 \
  -p 4318:4318 \
jaegertracing/jaeger:latest

quarkus.otel.traces.exporter=logging

<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-logging</artifactId>
</dependency>

$ curl http://localhost:8080/hello
hello

10:49:02 INFO  traceId=, parentId=, spanId=, sampled= [io.quarkus] (main) Installed features: [cdi, opentelemetry, resteasy-client, resteasy, smallrye-context-propagation, vertx]
10:49:03 INFO  traceId=17ceb8429b9f25b0b879fa1503259456, parentId=3125c8bee75b7ad6, spanId=58ce77c86dd23457, sampled=true [or.ac.op.TracedResource] (executor-thread-1) hello
10:49:03 INFO  traceId=ad23acd6d9a4ed3d1de07866a52fa2df, parentId=, spanId=df13f5b45cf4d1e2, sampled=true [or.ac.op.TracedResource] (executor-thread-0) hello

# enable tracing
quarkus.datasource.jdbc.telemetry=true

# configure datasource
quarkus.datasource.db-kind=postgresql
quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/mydatabase

@Singleton
public class CustomConfiguration {

    /** Creates a custom IdGenerator for OpenTelemetry */
    @Produces
    @Singleton
    public IdGenerator idGenerator() {
        return AwsXrayIdGenerator.getInstance();
    }
}

# build time property only:
quarkus.otel.traces.sampler=traceidratio
# Runtime property:
quarkus.otel.traces.sampler.arg=0.5

@ApplicationScoped
class SpanBean {
    @WithSpan
    void span() {

    }

    @WithSpan("name")
    void spanName() {

    }

    @WithSpan(kind = SERVER)
    void spanKind() {

    }

    @WithSpan
    void spanArgs(@SpanAttribute(value = "arg") String arg) {

    }

    @AddingSpanAttributes
    void addArgumentToExistingSpan(@SpanAttribute(value = "arg") String arg) {

    }
}

@Inject
Tracer tracer;

...

public void tracedWork() {
    Span span = tracer.spanBuilder("My custom span")
        .setAttribute("attr", "attr.value")
        .setParent(Context.current().with(Span.current()))
        .setSpanKind(SpanKind.INTERNAL)
        .startSpan();

    // traced work

    span.end();
}

Uni<String> uni = Uni.createFrom().item("hello")
        //start trace here
        .onItem().transform(item -> item + " world")
        .onItem().transform(item -> item + "!")
        //end trace here
        .subscribe().with(
                item -> System.out.println("Received: " + item),
                failure -> System.out.println("Failed with " + failure)
        );

import static io.quarkus.opentelemetry.runtime.tracing.mutiny.MutinyTracingHelper.wrapWithSpan;
...
@Inject
Tracer tracer;
...
Context context = Context.current();
Uni<String> uni = Uni.createFrom().item("hello")
        .transformToUni(m -> wrapWithSpan(tracer, Optional.of(context), "my-span-name",
                                Uni.createFrom().item(m)
                                    .onItem().transform(item -> item + " world")
                                    .onItem().transform(item -> item + "!")
        ))
        .subscribe().with(
                item -> System.out.println("Received: " + item),
                failure -> System.out.println("Failed with " + failure)
        );

Multi.createFrom().items("Alice", "Bob", "Charlie")
        .transformToMultiAndConcatenate(m -> TracingHelper.withTrace("my-span-name",
                                Multi.createFrom().item(m)
                                    .onItem().transform(name -> "Hello " + name)
        ))
        .subscribe().with(
                item -> System.out.println("Received: " + item),
                failure -> System.out.println("Failed with " + failure)
        );

TracingMetadata tm = TracingMetadata.withPrevious(Context.current());
Message out = Message.of(...).withMetadata(tm);

quarkus.otel.security-events.enabled=true (1)

@ApplicationScoped
public static class HelloSpan {

    private final Tracer tracer;

    // Instead of using @Inject on the tracer attribute
    public HelloSpan(Tracer tracer) {
        // The same as openTelemetry.getTracer("io.quarkus.opentelemetry");
        this.tracer = tracer;
    }

    public String helloManualSpan() {
        // Create a new span
        Span span = tracer.spanBuilder("HelloBean.helloManualSpan").startSpan();
        // Make sure span scope is closed
        try (Scope scope = span.makeCurrent()) { (1)
            // Add an attribute
            span.setAttribute("myAttributeName", "myValue");
            // Execute logic...
            return "Hello from Quarkus REST";
        } catch (Exception ignored) {
            // Store potential exceptions.
            span.recordException(ignored);
        } finally {
            // Whatever happens above, the span will be closed.
            span.end();
        }
        return "failover message";
    }
}

@ApplicationScoped
public static class HelloPropagation {

    /**
     * How data is stored
     */
    private static final TextMapSetter<Map<String, String>> MAP_SETTER = new TextMapSetter<Map<String, String>>() {
        @Override
        public void set(@Nullable Map<String, String> carrier, String key, String value) {
            carrier.put(key, value); (1)
        }
    };

    /**
     * How data is retrieved
     */
    private static final TextMapGetter<Map<String, String>> MAP_GETTER = new TextMapGetter<>() {

        @Override
        public Iterable<String> keys(Map<String, String> carrier) {
            return carrier == null ? emptyList() : carrier.keySet();
        }

        @Override
        public @Nullable String get(@Nullable Map<String, String> carrier, String key) {
            return carrier == null && key != null ? null : carrier.get(key); (2)
        }
    };

    private final Tracer tracer;
    private final OpenTelemetry openTelemetry;

    // Instead of using @Inject on the tracer attribute
    public HelloPropagation(Tracer tracer, OpenTelemetry openTelemetry) {
        this.openTelemetry = openTelemetry;
        // The same as openTelemetry.getTracer("io.quarkus.opentelemetry");
        this.tracer = tracer;
    }

    public String createParentContext() { (3)
        // Create the first manual span
        Span parentSpan = tracer.spanBuilder("parent-span").startSpan();

        try (Scope ignored = parentSpan.makeCurrent()) {
            // inject into a temporary map and return the traceparent header value
            // This can be stored in any data structure containing metadata in the payload to ship.
            // As an example, for HTTP the headers, for JMS a message attribute
            Map<String, String> tempCarrier = new HashMap<>();

            // We will use The MAP_SETTER to place the header containing the OTel Context in the tempCarrier
            openTelemetry.getPropagators()
                    .getTextMapPropagator()
                    .inject(Context.current(), tempCarrier, MAP_SETTER);

            // W3C traceparent header key is "traceparent"
            return tempCarrier.get("traceparent");
        } finally {
            parentSpan.end();
        }
    }

    public void receiveAndUseContext(String traceparent) { (4)
        // Rebuild a tempCarrier map that contains the "traceparent" header data
        Map<String, String> tempCarrier = new HashMap<>();
        tempCarrier.put("traceparent", traceparent);

        // Extract context from the tempCarrier
        Context extracted = openTelemetry.getPropagators()
                .getTextMapPropagator()
                .extract(Context.current(), tempCarrier, MAP_GETTER);

        // Optionally check whether a parent span was found:
        boolean hasParent = Span.fromContext(extracted).getSpanContext().isValid();

        // Start a child span with the extracted context as explicit parent
        Span child = tracer.spanBuilder("child-span")
                .setParent(extracted)
                .startSpan();

        try (Scope scope = child.makeCurrent()) {
            // Simulate work under child span
            logger.infov("Child span started. Extracted parent valid? {0}", hasParent);
        } finally {
            child.end();
        }
    }

        public Map<String, String> createBaggage(String withValue) {
            // Baggage can be used to send Application specific data using the OpenTelemetry propagation mechanism
            Baggage baggage = Baggage.builder()
                    .put("baggage_key", withValue, BaggageEntryMetadata.empty())
                    .build();
            Context context = baggage.storeInContext(Context.current());

            // We use this to store the header data to ship out.
            Map<String, String> tempCarrier = new HashMap<>();

            // We will use The MAP_SETTER to place the header containing the OTel Context in the tempCarrier
            try (Scope ignored = context.makeCurrent()) {
                openTelemetry.getPropagators()
                        .getTextMapPropagator()
                        .inject(Context.current(), tempCarrier, MAP_SETTER);
            }
            return tempCarrier;
        }

        public String receiveAndUseBaggage(Map<String, String> headers) {
            // Extract context from the tempCarrier
            Context extracted = openTelemetry.getPropagators()
                    .getTextMapPropagator()
                    .extract(Context.current(), headers, MAP_GETTER);
            // Retrieve the baggage contents
            Baggage baggage = Baggage.fromContext(extracted);
            BaggageEntry baggageKey = baggage.asMap().get("baggage_key");
            return baggageKey != null ? baggageKey.getValue() : null;
        }

quarkus.otel.instrument.grpc=false
quarkus.otel.instrument.messaging=false
quarkus.otel.instrument.resteasy-client=false
quarkus.otel.instrument.rest=false
quarkus.otel.instrument.resteasy=false