Context.current() always empty.

[maxim-badarau-m10]

We are having reactive context, so followed lates PR to accommodate the solution as we are still using spring-boot 3.0.6.
Implemented:

public class TelemetryFilterConfig implements WebFilter, Ordered {

    private final ServerWebExchangeAttributesGetter serverWebExchangeAttributesGetter;

    private final Instrumenter<ServerWebExchange, ServerWebExchange> instrumenter;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        Context parentContext = Context.current();
        Mono<Void> source = chain.filter(exchange);
        return new TelemetryMonoWrapper(source, instrumenter, serverWebExchangeAttributesGetter, parentContext, exchange);
    }

    @Override
    public int getOrder() {
//        return Ordered.HIGHEST_PRECEDENCE + 1;
        return -1;
    }

}

also to mentioned that having Ordered.HIGHEST_PRECEDENCE + 1 will actually get blocked in: !instrumenter.shouldStart(parentContext, exchange)
After this filter, in the chain is decorator filter, having main purpose of logging request/response:

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        if (!passToLog(exchange)) {
            return chain.filter(exchange);
        }
        BodyCaptureExchange bodyCaptureExchange = new BodyCaptureExchange(exchange, obfuscateHeaders, UUID.randomUUID());
        return bodyCaptureExchange.getRequest().getFullBody()
                .doOnSuccess(requestBodyLog -> log.info("Request: {}", requestBodyLog))
                .flatMap(unused -> chain.filter(bodyCaptureExchange))
                .doOnSuccess(unused -> log.info("Response: {}", bodyCaptureExchange.getResponse().getFullBody()));
    }

    private boolean passToLog(ServerWebExchange exchange) {
        String path = Optional.ofNullable(exchange)
                .map(ServerWebExchange::getRequest)
                .map(ServerHttpRequest::getPath)
                .map(PathContainer::value)
                .orElse("");
        for (String value : exclude) {
            if (!path.isBlank() && path.startsWith(value)) {
                return false;
            }
        }
        return true;
    }

    @Override
    public int getOrder() {
        return 1;
    }

at any given time, after:

    @Override
    public void subscribe(CoreSubscriber<? super Void> actual) {
        if (!instrumenter.shouldStart(parentContext, exchange)) {
            source.subscribe(actual);
            return;
        }
        Context currentContext = instrumenter.start(parentContext, exchange);
        try (Scope ignored = currentContext.makeCurrent()) {
            this.source.subscribe(
                    new TelemetryWrappedSubscriber(actual, currentContext, instrumenter, serverWebExchangeAttributesGetter, exchange));
        }
    }

starting on subscribe new context, calling Context.current() is always null
Trying to apply and customise this solution: https://github.com/open-telemetry/opentelemetry-java-instrumentation/pull/7899/files#diff-75440060d9275950a4421e5518996d91f2055c75ff35fb105194ccec6cf644a6
Configuration looks like:

@Configuration
public class OpenTelemetryConfiguration {

    @Bean
    public Resource resource(@Value("${spring.application.name}") String applicationName) {
        return Resource.getDefault().toBuilder().put(ResourceAttributes.SERVICE_NAME, applicationName)
                .put(ResourceAttributes.SERVICE_VERSION, "1.0.0").build();
    }

    @Bean
    public SdkTracerProvider sdkTracerProvider(Resource resource) {
        return SdkTracerProvider.builder()
//                .addSpanProcessor(SimpleSpanProcessor.create(LoggingSpanExporter.create()))
                .setResource(resource)
                .build();
    }

    @Bean
    public SdkMeterProvider sdkMeterProvider(Resource resource) {
        return SdkMeterProvider.builder()
                .registerMetricReader(PeriodicMetricReader.builder(LoggingMetricExporter.create()).build())
                .setResource(resource)
                .build();
    }

    @Bean
    public SdkLoggerProvider sdkLoggerProvider(Resource resource) {
        return SdkLoggerProvider.builder()
                .addLogRecordProcessor(BatchLogRecordProcessor.builder(SystemOutLogRecordExporter.create()).build())
                .setResource(resource)
                .build();
    }

    @Bean
    public OpenTelemetry openTelemetry(SdkTracerProvider sdkTracerProvider,
                                       SdkMeterProvider sdkMeterProvider,
                                       SdkLoggerProvider sdkLoggerProvider) {
        return OpenTelemetrySdk.builder()
                .setTracerProvider(sdkTracerProvider)
                .setMeterProvider(sdkMeterProvider)
                .setLoggerProvider(sdkLoggerProvider)
                .setPropagators(ContextPropagators.create(TextMapPropagator.composite(W3CTraceContextPropagator.getInstance(),
                        W3CBaggagePropagator.getInstance())))
                .build();
    }

    @Bean
    public OtlpHttpSpanExporter otlpHttpSpanExporter(@Value("${tracing.url}") String url) {
        return OtlpHttpSpanExporter.builder().setEndpoint(url).build();
    }

    @Bean
    public SpanNameExtractor<ServerWebExchange> spanNameExtractor(ServerWebExchangeAttributesGetter serverWebExchangeAttributesGetter) {
        return HttpSpanNameExtractor.create(serverWebExchangeAttributesGetter);
    }

    @Bean
    public Instrumenter<ServerWebExchange, ServerWebExchange> instrumenter(OpenTelemetry openTelemetry,
                                                                           @Value("${spring.application.name}") String applicationName,
                                                                           SpanNameExtractor<ServerWebExchange> spanNameExtractor) {
        return Instrumenter.<ServerWebExchange, ServerWebExchange>builder(openTelemetry, applicationName, spanNameExtractor)
                .buildInstrumenter();
    }