Propagation du contexte et bagages

import io.opentelemetry.api.trace.Span; 
import io.opentelemetry.api.trace.SpanContext;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.propagation.TextMapSetter;
import java.util.HashMap;
import java.util.Map;

public class ContextInjector {

  public static void main(String[] args) {
    // Simulate an active span context
    SpanContext simulatedSpanContext =
        SpanContext.create(
            "0123456789abcdef0123456789abcdef", // Trace ID
            "fedcba9876543210", // Span ID
            io.opentelemetry.api.trace.TraceFlags.getDefault(),
            io.opentelemetry.api.trace.TraceState.getDefault());
    Span span = Span.wrap(simulatedSpanContext);
    Context context = Context.current().with(span);

    Map<String, String> headers = new HashMap<>();
    TextMapSetter<Map<String, String>> setter = Map::put;

    // OpenTelemetry usually handles this implicitly
    // Here, we simulate injecting context into headers
    // using a simplified representation.
    headers.put("traceparent", "00-" + simulatedSpanContext.getTraceId() + "-" + simulatedSpanContext.getSpanId() + "-01");
    
    System.out.println("Injected Headers:");
    headers.forEach((key, value) -> System.out.println(key + ": " + value));
  }
}

import io.opentelemetry.api.trace.SpanContext;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.propagation.TextMapGetter;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import java.util.HashMap;
import java.util.Map;

public class ContextExtractor {

  public static void main(String[] args) {
    Map<String, String> incomingHeaders = new HashMap<>();
    incomingHeaders.put("traceparent", "00-112233445566778899aabbccddeeff00-aabbccddeeff0011-01");

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

      @Override
      public String get(Map<String, String> carrier, String key) {
        return carrier.get(key);
      }
    };

    // In a real app, OpenTelemetry.getGlobalPropagators() would be used
    TextMapPropagator propagator = OpenTelemetrySdk.builder().build()
        .getPropagators().getTextMapPropagator();

    Context extractedContext = propagator.extract(Context.current(), incomingHeaders, getter);
    SpanContext spanContext = Span.fromContext(extractedContext).getSpanContext();

    System.out.println("Extracted Trace ID: " + spanContext.getTraceId());
    System.out.println("Extracted Span ID: " + spanContext.getSpanId());
  }
}

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

public class BaggageUsage {

  public static void main(String[] args) {
    // --- Service A: Add to Baggage ---
    System.out.println("--- Service A ---");
    Context contextWithBaggage = Baggage.current()
        .toBuilder()
        .put("user.id", "12345")
        .put("ab.test.group", "variantA")
        .build()
        .make   Current(); // Make this baggage active in current context

    System.out.println("Added user.id: " + Baggage.current().getEntryValue("user.id"));
    System.out.println("Added ab.test.group: " + Baggage.current().getEntryValue("ab.test.group"));
    
    // Simulate passing context (and thus baggage) to Service B
    // In a real app, this would be via HTTP headers, etc.
    callServiceB(contextWithBaggage);
  }

  public static void callServiceB(Context parentContext) {
    // --- Service B: Retrieve from Baggage ---
    System.out.println("\n--- Service B ---");
    // Activate the context from Service A
    try (io.opentelemetry.context.Scope scope = parentContext.makeCurrent()) {
      Baggage currentBaggage = Baggage.current();
      System.out.println("Retrieved user.id: " + currentBaggage.getEntryValue("user.id"));
      System.out.println("Retrieved ab.test.group: " + currentBaggage.getEntryValue("ab.test.group"));
    }
  }
}