Best way to do tracing in a completableFuture.

[Saewo0]

Hi everybody,
I am having trouble finding a way to do tracing with a chain of completableFutures.

For example, I have a completableFuture
future = CompletableFuture.completedFuture(instance).thenCompose(instance -> process(instance)).whenComplete((result, throwable) -> {error handling)

What's the best way to start a span in the first thenCompose before process() and end it in the whenComplete?

Thanks in advance!

[jkwatson]

This is just a suggestion, as your use-case may not work for it, but approach is to make sure you run your CompletableFutures with an Executor, and use our wrapper Context.taskWrapping(executor) as the Executor for that Executor.

That will get you context propagation..then you can simply start a span and makeCurrent() when you want to start it, and end it by getting it out of the Context when you want to.

Caveat: I haven't tried this myself, but it seems like it should work.

[Saewo0]

Thanks, John, but I am trying to run the task synchronously. That means I don't have an executor and I don't really need to worry about context propagation.

My question is more like how to retrieve a variable(which is a span) that is declared in former completion stages.

I do have a question for you, why don't you expose a method like "start" to spans, other than the method "startSpan" for the spanbuilder?

If I have this "start" method, I can declare an un-started span outside the completableFuture, then start it in the first stage and end it in the final stage. Just like this:
Span span = tracer.spanBuilder().build()
future = CompletableFuture.completedFuture(instance).thenCompose(instance -> { span.start(); return process(instance);}).whenComplete((result, throwable) -> span.end())

Instead, now I can only declare this span in the first stage and there's no way to retrieve it in the final stage..

[jkwatson]

The reason for that, IIRC, is that there are things that we require to be locked in place about the Span before it starts, so that Samplers can have guarantees about invariants about the span (the Kind being one example of that). If we had a start() method, we would be in a situation where you could make calls on the Span object that could potentially break those invariants, or we'd have to introduce some kind of intermediate UnstartedSpan type that looked just like our current SpanBuilder.

You could always allocate an AtomicReference<Span> before you start your CompletableFuture pipeline and populate it when you start the span. It's not pretty, but if you know you're single-threaded then it should work fine.

[Saewo0]

I get the idea, and this AtomicReference is definitely a good choice! Thanks, John!