MDC context propagation not working for Vert.x Event Bus

[javiervieraacc]

Describe the bug

• Quarkus Version: 3.23.2
• Java 21
• Create a simple application which receives an http request, set a test field in MDC and send an event to a event bus. Same class consumes the even and print MDC context to verify context propagation
  ExampleResource .java:

package org.acme;

import io.quarkus.vertx.ConsumeEvent;
import io.vertx.core.eventbus.EventBus;
import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import org.jboss.logging.Logger;
import org.slf4j.MDC;

@Path("/hello")
public class ExampleResource {

    private static final Logger LOG = Logger.getLogger(ExampleResource.class);


    @Inject
    private EventBus bus;

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {

        MDC.put("test", "test");
        bus.request("test", "aaaa");
        return "Hello from Quarkus REST";
    }

    @ConsumeEvent("test")
    public void notifyCompletedEvents(String messagePayload) {
        LOG.infof(
                "Consumer: Entering notifyCompletedEvents - Received payload: %s, current MDC: %s",
                messagePayload, MDC.getCopyOfContextMap());
        LOG.infof(
                "Consumer: Specific MDC 'test' field: %s", MDC.get("test")); // Directly check the field
        // ... (your commented-out socket logic) ...
        // IMPORTANT: Clear MDC in the consumer's thread after processing
        MDC.clear();
        LOG.infof("Consumer: MDC after cleanup: %s", MDC.getCopyOfContextMap());
        // sendEventToSocket(MessageType.COMPLETED, cartId);
    }
}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.acme</groupId>
    <artifactId>code-with-quarkus</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <compiler-plugin.version>3.14.0</compiler-plugin.version>
        <maven.compiler.release>21</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <quarkus.platform.artifact-id>quarkus-bom</quarkus.platform.artifact-id>
        <quarkus.platform.group-id>io.quarkus.platform</quarkus.platform.group-id>
        <quarkus.platform.version>3.23.2</quarkus.platform.version>
        <skipITs>true</skipITs>
        <surefire-plugin.version>3.5.3</surefire-plugin.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>${quarkus.platform.group-id}</groupId>
                <artifactId>${quarkus.platform.artifact-id}</artifactId>
                <version>${quarkus.platform.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-arc</artifactId>
        </dependency>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-junit5</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.rest-assured</groupId>
            <artifactId>rest-assured</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>${quarkus.platform.group-id}</groupId>
                <artifactId>quarkus-maven-plugin</artifactId>
                <version>${quarkus.platform.version}</version>
                <extensions>true</extensions>
                <executions>
                    <execution>
                        <goals>
                            <goal>build</goal>
                            <goal>generate-code</goal>
                            <goal>generate-code-tests</goal>
                            <goal>native-image-agent</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${compiler-plugin.version}</version>
                <configuration>
                    <parameters>true</parameters>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>${surefire-plugin.version}</version>
                <configuration>
                    <systemPropertyVariables>
                        <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                        <maven.home>${maven.home}</maven.home>
                    </systemPropertyVariables>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>${surefire-plugin.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>integration-test</goal>
                            <goal>verify</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <systemPropertyVariables>
                        <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
                        <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                        <maven.home>${maven.home}</maven.home>
                    </systemPropertyVariables>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <profiles>
        <profile>
            <id>native</id>
            <activation>
                <property>
                    <name>native</name>
                </property>
            </activation>
            <properties>
                <skipITs>false</skipITs>
                <quarkus.native.enabled>true</quarkus.native.enabled>
            </properties>
        </profile>
    </profiles>
</project>

Expected behavior

MDC set in the producer thread (test=test) should be present in the consumer thread's MDC map.

Actual behavior

MDC is empty in the consumer thread.

How to Reproduce?

1. Create a sample java project with provides pom.xml and ExampleResource .java
2. mvn quarkus:dev
3. Access http://localhost:8080/hello
4. Observe the logs.

Output of uname -a or ver

Linux c11-rxo1coocwus 6.6.87.1-microsoft-standard-WSL2 #1 SMP PREEMPT_DYNAMIC Mon Apr 21 17:08:54 UTC 2025 x86_64 x86_64 x86_64 GNU/Linux

Output of java -version

openjdk version "21.0.7" 2025-04-15 LTS

Quarkus version or git rev

3.23.2

Build tool (ie. output of mvnw --version or gradlew --version)

Apache Maven 3.9.6 (bc0240f3c744dd6b6ec2920b3cd08dcc295161ae)

Additional information

No response

[quarkus-bot]

/cc @FroMage (context-propagation), @manovotn (context-propagation)

[sberyozkin]

Also CC Clement @cescoffier

[luneo7]

Contextual data is not propagated in the event bus, if you want to propagate MDC there you must add it to the header of the message, something like:

package org.acme;

import io.quarkus.runtime.Startup;
import io.quarkus.vertx.ConsumeEvent;
import io.vertx.core.eventbus.EventBus;
import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import org.jboss.logging.Logger;
import org.slf4j.MDC;

@Path("/hello")
public class ExampleResource {
    private static final Logger LOG = Logger.getLogger(ExampleResource.class);

    private final EventBus bus;

    @Inject
    public ExampleResource(EventBus bus) {
        this.bus = bus;
    }

    @Startup
    void startup() {
        bus.addOutboundInterceptor(event -> {
            MDC.getCopyOfContextMap().forEach((k, v) -> event.message().headers().add("mdc|" + k, v));
            event.next();
        });
        bus.addInboundInterceptor(event -> {
            event.message().headers().forEach(entry -> {
                String key = entry.getKey();
                if (key.startsWith("mdc|")) {
                    MDC.put(key.substring(4), entry.getValue());
                }
            });
            event.next();
        });
    }

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        MDC.put("test", "test");
        bus.request("test", "aaaa");

        return "Hello from Quarkus REST";
    }

    @ConsumeEvent("test")
    public void notifyCompletedEvents(String messagePayload) {
        LOG.infof(
                "Consumer: Entering notifyCompletedEvents - Received payload: %s, current MDC: %s",
                messagePayload, MDC.getCopyOfContextMap());
    }
}

[FroMage]

@cescoffier should we be providing something out of the box for propagating MDC contexts in MP-CP and/or Vert.x event bus?

[cescoffier]

Sure, but I think it should be possible to disable it, as the event bus can be distributed or hybrid (and you probably don't want to serialize your context).

The event bus consumer is invoked on a different duplicated context (potentially a different event loop). There is no easy way to pass a duplicated context implicitly.

[FroMage]

Apparently MDC uses a ThreadLocal, so at least it should be possible to provide an MP-CP implementation to propagate it. But that won't help wrt. event bus which doesn't use MP-CP 🤷

[luneo7]

So there in VertxMDC we would de using vertx local context data, as that is running inside a vertx thread =) MDC just fallback to threadlocal when not in a vertx thread.

[anwarjabaldecath]

Contextual data is not propagated in the event bus, if you want to propagate MDC there you must add it to the header of the message, something like:

package org.acme;

import io.quarkus.runtime.Startup;
import io.quarkus.vertx.ConsumeEvent;
import io.vertx.core.eventbus.EventBus;
import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import org.jboss.logging.Logger;
import org.slf4j.MDC;

@path("/hello")
public class ExampleResource {
private static final Logger LOG = Logger.getLogger(ExampleResource.class);

private final EventBus bus;

@Inject
public ExampleResource(EventBus bus) {
    this.bus = bus;
}

@Startup
void startup() {
    bus.addOutboundInterceptor(event -> {
        MDC.getCopyOfContextMap().forEach((k, v) -> event.message().headers().add("mdc|" + k, v));
        event.next();
    });
    bus.addInboundInterceptor(event -> {
        event.message().headers().forEach(entry -> {
            String key = entry.getKey();
            if (key.startsWith("mdc|")) {
                MDC.put(key.substring(4), entry.getValue());
            }
        });
        event.next();
    });
}

@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
    MDC.put("test", "test");
    bus.request("test", "aaaa");

    return "Hello from Quarkus REST";
}

@ConsumeEvent("test")
public void notifyCompletedEvents(String messagePayload) {
    LOG.infof(
            "Consumer: Entering notifyCompletedEvents - Received payload: %s, current MDC: %s",
            messagePayload, MDC.getCopyOfContextMap());
}

}

This solution could be tricky because it never clears the MDC, then if the thread pick up another process that does not override the MDC values, the MDC will have the values of the last process.
The clear needs to be done manually after each "@ConsumeEvent" process