Simple tracer for logging traceIds

[pwfarwell]

What is the simplest way to create a tracer? Our application doesn't need to export info to a remote provider like Jaeger. We are using OpenTelemetry to track our traceIds in our logs.

The getting started example on your manual instrumentation page uses a OtlpGrpcSpanExporter:

    SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder()
        .addSpanProcessor(BatchSpanProcessor.builder(OtlpGrpcSpanExporter.builder().build()).build())
        .build();

    OpenTelemetry openTelemetry = OpenTelemetrySdk.builder()
        .setTracerProvider(sdkTracerProvider)
        .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance()))
        .buildAndRegisterGlobal();

    Tracer tracer =
         openTelemetry.getTracer("instrumentation-library-name", "1.0.0");

However, that is more heavy-weight than we need, as it attempts to connect to a remote server.

I've heard that OpenTelemetry supports something called an "In-memory exporter", but I don't see any documentation for that in the Java OTEL release. Does it exist for Java?

When we started with java OTEL version 0.12, we used the io.opentelemetry.instrumentation.api.tracer.BaseTracer to create a simple tracer. However, the BaseTracer was removed in more recent version, and there doesn't appear to be a replacement.

Any help is greatly appreciated, especially an example or a link to documentation.

[jkwatson]

Hi @pwfarwell . The opentelemetry-java project does have an InMemorySpanExporter, but it's a testing artifact, not something intended for use in production code.

First question: are you using the OpenTelemetry javaagent, or are you doing all manual instrumentation?

I'm a little confused about what your needs are. You don't need to have any exporter configured at all, if you don't want to export any spans from your application. If all you want is having traceids injected into your logging MDC, then you can skip the exporter configuration altogether and just use the MDC injection piece that you need.

[pwfarwell]

Thanks @jkwatson I think this puts me on the correct path. I took a look at the online docs for the javaagent, https://github.com/open-telemetry/opentelemetry-java-instrumentation.
Just want to confirm my understanding.

I need to launch my japp with with the otel agent:

java -javaagent:path/to/opentelemetry-javaagent-all.jar \
     -jar myapp.jar

And then configure the exporter to "none"

otel.traces.exporter=none

(Or as "logging"? otel.traces.exporter=logging)

Is that correct?

I wasn't sure what you meant by "just use the MDC injection piece that you need"

If all you want is having traceids injected into your logging MDC, then you can skip the exporter configuration altogether and just use the MDC injection piece that you need.

After I start my app with the otel javaagent, and configure my Log4J appender pattern to consume the traceIds, will the javaagent automatically inject the traceIds into the MDC logging context?

[jkwatson]

Yes, you can configure to none or logging as you prefer (logging will log out all the spans that are created...this might be useful to make sure that everything else is working).

I think you are correct that the MDC should be populated by the agent instrumentation, but I'm not an expert in this particular bit and haven't tried it myself.

[pwfarwell]

Thanks again @jkwatson The reason I thought I needed a handle to a tracer is to create a new traceId when our code is at the beginning of a call stack (and we don't want to propogate the existing trace context). For instance:

Span newSpan = **tracer**.spanBuilder("my new span").startSpan();

I'm assuming the only way to create a new traceId (new trace context) is through a tracer instance and its API. Or is that incorrect?

When using the javaagent, how do I get a handle to a tracer instance?

For the manual instrumentation, there are three steps: 1) build a SdkTracerProvider 2) build an OpenTelemetry instance then 3) get the tracer:

Tracer tracer =
         openTelemetry.getTracer("instrumentation-library-name", "1.0.0");

What's the equivalent when using the javaagent?

[jkwatson]

If you just want to create a new Span on a method, the easiest way is to use the @WithSpan annotation on your method, and let the agent take care of the details.

If you really feel like you need your own tracer instance, the agent initializes the GlobalOpenTelemetry instance for you, so you could use that to get a handle to a tracer with your own custom name/version.