Hi,

I'm using a library which tries to log to the active span from within a Mono.create block.
The TracerSubscriber does not seem to set the active span for this case.

        Span foo = tracer.buildSpan("foo").start();

        Mono.create(sink -> {
            tracer.activeSpan().log("hoho");
            sink.success("asdas");
        })
            .subscriberContext(c -> c.put(Span.class, foo))
            .doOnTerminate(() -> foo.finish())
            .block();

Hello!

Is there any reason to not wrap TracedSubscriber.onError() and TracedSubscriber.onComplete() within the active span?

I would like to access the span in both cases in order to have a clean log correlation.

Happy to contribute if needed!
Thanks.

We are using ProjectReactor and grpc, as well as using reactive drivers for postgres r2dbc-postgresql.
There are 3 microservices.
A grpc request is made from the pvi-adapter application, to the ed-server application, then a transaction is opened, some kind of business logic is executed, then a grpc call to the dicts server is made.
When you start the application for the first time and receive the first grpc request from pvi-adapter, all spans are appended in the correct sequence and to the correct trace.
But all subsequent requests received via grpc from pvi-adpater are also bound to the span that was formed at the first request.
To pass the span in the reactor, we use
Hooks.onEachOperator (TracedSubscriber.asOperator (tracer));
Hooks.onLastOperator (TracedSubscriber.asOperator (tracer));
as you have written about it https://github.com/opentracing-contrib/java-reactor

To pass the span through grpc, we use
TracingServerInterceptor and TracingClientInterceptor from repository
https://github.com/opentracing-contrib/java-grpc

After a long debugging, I came to the conclusion that the problem is that the postgres r2dbc driver keeps the context passed through TracedSubscriber until the connection to the database is interrupted io.r2dbc.postgresql.client.ReactorNettyClient

https://github.com/pgjdbc/r2dbc-postgresql/blob/main/src/main/java/io/r2dbc/postgresql/client/ReactorNettyClient.java

The question is who faced such a problem and how to get around it? Now it turns out that using TracedSubscriber in a fully reactive environment with reactive drivers for postgres is not possible.

Hi,

We ran into an issue where the Java SpecialAgent broke a Reactor application. Apparently the application is using a block() call (we know this is probably an anti-pattern and are looking to fix it) that works fine using the FluxElapsed.ElapsedSubscriber, but fails when the TracedSubscriber wrapper is added.

It looks like this is due to the fact that the threading can change since TracedSubscriber implements the SpanSubscription interface which always returns Fuseable.NONE for Fuseable.QueueSubscription.requestFusion.

Would it be possible to preserve the fusion mode from the wrapped subscriber instead of always returning NONE?

Please publish opentracing-reactor to Maven Central so that it can be imported from other projects.

(In particular, I'm planning to add a Spring Boot starter for it in java-spring-cloud).

Thank you!

Quick question: are traces propagated also in reactive chains where subscribeOn is used? I don't seem to get this to work properly and traces disappear when for example .subscribeOn(Schedulers.elastic()) is used. Thanks in advance

@jam01 would you like to take this one?