Managed Service for OpenTelemetry:Report Java application data with Jaeger

Step 1: Add the Jaeger client dependency

Add the following dependency to your pom.xml:

<dependency>
    <groupId>io.jaegertracing</groupId>
    <artifactId>jaeger-client</artifactId>
    <version>0.31.0</version>
</dependency>

Step 2: Initialize the tracer

Create a tracer that manages span lifecycle and context propagation. The configuration specifies the reporting endpoint, sampling rate, and service identity.

// Replace manualDemo with your application name.
io.jaegertracing.Configuration config = new io.jaegertracing.Configuration("manualDemo");
io.jaegertracing.Configuration.SenderConfiguration sender = new io.jaegertracing.Configuration.SenderConfiguration();
// Replace <endpoint> with the endpoint obtained in "Get a reporting endpoint".
sender.withEndpoint("<endpoint>");
config.withSampler(new io.jaegertracing.Configuration.SamplerConfiguration().withType("const").withParam(1));
config.withReporter(new io.jaegertracing.Configuration.ReporterConfiguration().withSender(sender).withMaxQueueSize(10000));
// Set resource tags such as the application version and deployment environment.
Map<String, String> map = new HashMap<>();
map.put("service.version", "1.0.0");
map.put("deployment.environment", "test");
config.withTracerTags(map);
GlobalTracer.register(config.getTracer());

Sampling configuration:

Step 3: Record requests with spans

Create a span to trace a request. Each span captures the operation name, timing, and custom tags:

Tracer tracer = GlobalTracer.get();
// Create a span.
Span span = tracer.buildSpan("parentSpan").withTag("myTag", "spanFirst").start();
tracer.scopeManager().activate(span, false);
tracer.activeSpan().setTag("methodName", "testTracing");
// Business logic
secondBiz();
span.finish();

Step 4 (optional): Create child spans

To trace sub-operations within a request, create child spans that reference the parent span:

Tracer tracer = GlobalTracer.get();
Span parentspan = tracer.activeSpan();
Tracer.SpanBuilder spanBuilder = tracer.buildSpan("childSpan").withTag("myTag", "spanSecond");
if (parentspan != null) {
    spanBuilder.asChildOf(parentspan).start();
}
Span childSpan = spanBuilder.start();
Scope scope = tracer.scopeManager().activate(childSpan); // Activate at request start.
// Business logic. Call buildSpan multiple times as needed.
childSpan.finish();
tracer.activeSpan().setTag("methodName", "testCall");

// Close the scope at request end.
scope.close();

Step 5 (optional): Add custom tags

Add custom tags to spans for easier troubleshooting. For example, record error states or return values:

tracer.activeSpan().setTag("methodName", "testCall");

Step 6: Propagate trace context across services

In a distributed system, Remote Procedure Call (RPC) requests carry trace context -- including TraceId, ParentSpanId, SpanId, and Sampled -- in HTTP headers. Use the Inject and Extract methods to pass this context between services.

On the client, inject the span context into the outgoing request:

private void attachTraceInfo(Tracer tracer, Span span, final Request request) {
    tracer.inject(span.context(), Format.Builtin.TEXT_MAP, new TextMap() {
        @Override
        public void put(String key, String value) {
            request.setHeader(key, value);
        }
        @Override
        public Iterator<Map.Entry<String, String>> iterator() {
            throw new UnsupportedOperationException("TextMapInjectAdapter should only be used with Tracer.inject()");
        }
    });
}

On the server, extract the span context from the incoming request:

protected Span extractTraceInfo(Request request, Tracer tracer) {
    Tracer.SpanBuilder spanBuilder = tracer.buildSpan("/api/xtrace/test03");
    try {
        SpanContext spanContext = tracer.extract(Format.Builtin.TEXT_MAP, new TextMapExtractAdapter(request.getAttachments()));
        if (spanContext != null) {
            spanBuilder.asChildOf(spanContext);
        }
    } catch (Exception e) {
        spanBuilder.withTag("Error", "extract from request fail, error msg:" + e.getMessage());
    }
    return spanBuilder.start();
}

Step 1: Add dependencies

Add the following dependencies to your pom.xml:

<dependency>
   <groupId>io.opentracing.contrib</groupId>
  <artifactId>opentracing-spring-cloud-starter</artifactId>
  <version>0.5.8</version>
</dependency>
<dependency>
  <groupId>io.jaegertracing</groupId>
  <artifactId>jaeger-client</artifactId>
  <version>1.4.0</version>
</dependency>

Step 2: Register the tracer bean

Register an OpenTracing Tracer bean in your Spring configuration. After registration, Spring Cloud auto-instrumentation handles span creation and context propagation for all supported components.

@Bean
public io.opentracing.Tracer tracer() {
    io.jaegertracing.Configuration config = new io.jaegertracing.Configuration("springFrontend");
    io.jaegertracing.Configuration.SenderConfiguration sender = new io.jaegertracing.Configuration.SenderConfiguration();
    sender.withEndpoint("<endpoint>");
    config.withSampler(new io.jaegertracing.Configuration.SamplerConfiguration().withType("const").withParam(1));
    config.withReporter(new io.jaegertracing.Configuration.ReporterConfiguration().withSender(sender).withMaxQueueSize(10000));
    return config.getTracer();
}

Step 1: Add the gRPC tracing dependency

Add the following dependency to your pom.xml:

<dependency>
    <groupId>io.opentracing.contrib</groupId>
    <artifactId>opentracing-grpc</artifactId>
    <version>0.2.3</version>
</dependency>

Step 2: Add a tracing interceptor to the server

Initialize the tracer, create a ServerTracingInterceptor, and attach it to the gRPC server:

import io.opentracing.Tracer;

public class YourServer {

    private int port;
    private Server server;
    private final Tracer tracer;

    private void start() throws IOException {
        ServerTracingInterceptor tracingInterceptor = new ServerTracingInterceptor(this.tracer);

        // If GlobalTracer is used:
        // ServerTracingInterceptor tracingInterceptor = new ServerTracingInterceptor();

        server = ServerBuilder.forPort(port)
            .addService(tracingInterceptor.intercept(someServiceDef))
            .build()
            .start();
    }
}

Step 3: Add a tracing interceptor to the client

Initialize the tracer, create a ClientTracingInterceptor, and attach it to the gRPC channel:

import io.opentracing.Tracer;

public class YourClient {

    private final ManagedChannel channel;
    private final GreeterGrpc.GreeterBlockingStub blockingStub;
    private final Tracer tracer;

    public YourClient(String host, int port) {

        channel = ManagedChannelBuilder.forAddress(host, port)
            .usePlaintext(true)
            .build();

        ClientTracingInterceptor tracingInterceptor = new ClientTracingInterceptor(this.tracer);

        // If GlobalTracer is used:
        // ClientTracingInterceptor tracingInterceptor = new ClientTracingInterceptor();

        blockingStub = GreeterGrpc.newBlockingStub(tracingInterceptor.intercept(channel));
    }
}

No data appears in the console

Debug the io.jaegertracing.thrift.internal.senders.HttpSender.send(Process process, List<Span> spans) method and check the return value.

Enable debug logging

To see whether spans are generated and sent, enable Jaeger client debug logging by adding the following JVM argument:

-Dorg.slf4j.simpleLogger.log.io.jaegertracing=debug

Check the application logs for span submission results. If spans appear in logs but not in the console, the endpoint URL or network configuration is likely incorrect.