Add test coverage for the fix quarkusio/quarkus#48057

Author: jcarranzan

http/vertx/pom.xml

@@ -23,6 +23,14 @@
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-micrometer-registry-prometheus</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-smallrye-health</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-smallrye-context-propagation</artifactId>
+        </dependency>
     </dependencies>
     <profiles>
         <profile>

http/vertx/src/main/java/io/quarkus/ts/vertx/ExternalHealthEndpoint.java

@@ -0,0 +1,46 @@
+package io.quarkus.ts.vertx;
+
+import java.util.List;
+
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.core.Response;
+
+import org.jboss.logmanager.MDC;
+
+import io.smallrye.health.SmallRyeHealthReporter;
+
+@Path("/external-health")
+@ApplicationScoped
+public class ExternalHealthEndpoint {
+
+    public static final String LOGGER_NAME = "test-logger";
+    public static final String MDC_KEY = "endpoint.context";
+    public static final String MDC_VALUE_PREFIX = "value-from-endpoint-";
+
+    @Inject
+    SmallRyeHealthReporter healthReporter;
+
+    @Inject
+    InMemoryLogHandler inMemoryLogHandler;
+
+    @GET
+    public Response triggerHealthChecks() {
+        InMemoryLogHandler.reset();
+        MDC.put(MDC_KEY, MDC_VALUE_PREFIX + "ExternalEndpoint");
+        // access the MDC context before calling the health reporter to cause the problem
+        MDC.clear();
+        // call the health reporter
+        return Response.ok(healthReporter.getHealth().getPayload()).build();
+
+    }
+
+    @GET
+    @Path("/log-records")
+    public List<String> logRecords() {
+        return inMemoryLogHandler.logRecords();
+    }
+
+}

http/vertx/src/main/java/io/quarkus/ts/vertx/InMemoryLogHandler.java

@@ -0,0 +1,58 @@
+package io.quarkus.ts.vertx;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.logging.ErrorManager;
+import java.util.logging.Formatter;
+import java.util.logging.LogRecord;
+
+import org.jboss.logmanager.ExtHandler;
+import org.jboss.logmanager.formatters.PatternFormatter;
+
+public class InMemoryLogHandler extends ExtHandler {
+    private static final PatternFormatter FORMATTER = new PatternFormatter(
+            "%d{HH:mm:ss} %-5p endpoint_context=%X{endpoint.context} [%c{2.}] (%t) %s%n");
+
+    private static final List<String> recordList = new CopyOnWriteArrayList<>();
+
+    public List<String> logRecords() {
+        return Collections.unmodifiableList(recordList);
+    }
+
+    public static void reset() {
+        recordList.clear();
+    }
+
+    @Override
+    public void publish(LogRecord record) {
+        String loggerName = record.getLoggerName();
+        if (loggerName != null && loggerName.equals(ExternalHealthEndpoint.LOGGER_NAME)) {
+            final String formatted;
+            final Formatter formatter = getFormatter();
+            try {
+                formatted = formatter.format(record);
+            } catch (Exception ex) {
+                reportError("Formatting error", ex, ErrorManager.FORMAT_FAILURE);
+                return;
+            }
+            if (!formatted.isEmpty()) {
+                recordList.add(formatted);
+            }
+        }
+    }
+
+    @Override
+    public Formatter getFormatter() {
+        return FORMATTER;
+    }
+
+    @Override
+    public void flush() {
+    }
+
+    @Override
+    public void close() throws SecurityException {
+    }
+
+}

http/vertx/src/main/java/io/quarkus/ts/vertx/InMemoryLogHandlerProducer.java

@@ -0,0 +1,36 @@
+package io.quarkus.ts.vertx;
+
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.event.Observes;
+import jakarta.enterprise.inject.Produces;
+import jakarta.inject.Singleton;
+
+import io.quarkus.bootstrap.logging.InitialConfigurator;
+import io.quarkus.runtime.ShutdownEvent;
+import io.quarkus.runtime.StartupEvent;
+
+@ApplicationScoped
+public class InMemoryLogHandlerProducer {
+
+    public volatile boolean initialized = false;
+
+    @Produces
+    @Singleton
+    public InMemoryLogHandler inMemoryLogHandler() {
+        return new InMemoryLogHandler();
+    }
+
+    public boolean isInitialized() {
+        return initialized;
+    }
+
+    void onStart(@Observes StartupEvent ev, InMemoryLogHandler inMemoryLogHandler) {
+        InitialConfigurator.DELAYED_HANDLER.addHandler(inMemoryLogHandler);
+        initialized = true;
+    }
+
+    void onStop(@Observes ShutdownEvent ev, InMemoryLogHandler inMemoryLogHandler) {
+        initialized = false;
+        InitialConfigurator.DELAYED_HANDLER.removeHandler(inMemoryLogHandler);
+    }
+}

http/vertx/src/main/java/io/quarkus/ts/vertx/MdcPropagationHealthCheck1.java

@@ -0,0 +1,25 @@
+package io.quarkus.ts.vertx;
+
+import jakarta.enterprise.context.ApplicationScoped;
+
+import org.eclipse.microprofile.health.HealthCheck;
+import org.eclipse.microprofile.health.HealthCheckResponse;
+import org.eclipse.microprofile.health.Liveness;
+import org.jboss.logging.Logger;
+import org.jboss.logmanager.MDC;
+
+@Liveness
+@ApplicationScoped
+public class MdcPropagationHealthCheck1 implements HealthCheck {
+
+    private static final Logger LOG = Logger.getLogger(ExternalHealthEndpoint.LOGGER_NAME);
+
+    @Override
+    public HealthCheckResponse call() {
+        MDC.put(ExternalHealthEndpoint.MDC_KEY, ExternalHealthEndpoint.MDC_VALUE_PREFIX + getClass().getSimpleName());
+        Object mdcValue = MDC.get(ExternalHealthEndpoint.MDC_KEY);
+        LOG.info("MDC in health check: " + mdcValue);
+        LOG.error("Test log with MDC");
+        return HealthCheckResponse.up("mdc-propagation-check");
+    }
+}

http/vertx/src/main/java/io/quarkus/ts/vertx/MdcPropagationHealthCheck2.java

@@ -0,0 +1,25 @@
+package io.quarkus.ts.vertx;
+
+import jakarta.enterprise.context.ApplicationScoped;
+
+import org.eclipse.microprofile.health.HealthCheck;
+import org.eclipse.microprofile.health.HealthCheckResponse;
+import org.eclipse.microprofile.health.Liveness;
+import org.jboss.logging.Logger;
+import org.jboss.logmanager.MDC;
+
+@Liveness
+@ApplicationScoped
+public class MdcPropagationHealthCheck2 implements HealthCheck {
+
+    private static final Logger LOG = Logger.getLogger(ExternalHealthEndpoint.LOGGER_NAME);
+
+    @Override
+    public HealthCheckResponse call() {
+        MDC.put(ExternalHealthEndpoint.MDC_KEY, ExternalHealthEndpoint.MDC_VALUE_PREFIX + getClass().getSimpleName());
+        Object mdcValue = MDC.get(ExternalHealthEndpoint.MDC_KEY);
+        LOG.info("MDC in health check: " + mdcValue);
+        LOG.error("Test log with MDC");
+        return HealthCheckResponse.up("mdc-propagation-check");
+    }
+}

http/vertx/src/main/java/io/quarkus/ts/vertx/MdcTestNativeConfiguration.java

@@ -0,0 +1,11 @@
+package io.quarkus.ts.vertx;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+@RegisterForReflection(targets = {
+        ExternalHealthEndpoint.class,
+}, classNames = {
+        "org.eclipse.parsson.JsonStringImpl",
+})
+public class MdcTestNativeConfiguration {
+}

http/vertx/src/test/java/io/quarkus/ts/vertx/MdcContextPropagationIT.java

@@ -0,0 +1,74 @@
+package io.quarkus.ts.vertx;
+
+import static io.restassured.RestAssured.given;
+import static org.awaitility.Awaitility.await;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.is;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.RepeatedTest;
+import org.junit.jupiter.api.Tag;
+
+import io.quarkus.test.scenarios.QuarkusScenario;
+
+@Tag("https://github.com/quarkusio/quarkus/discussions/47481")
+@QuarkusScenario
+public class MdcContextPropagationIT {
+
+    @BeforeEach
+    public void clearLogs() {
+        InMemoryLogHandler.reset();
+    }
+
+    @RepeatedTest(5)
+    void testMdcIsPropagatedFromExternalEndpointToHealthCheck() {
+        given()
+                .when()
+                .get("/external-health")
+                .then()
+                .statusCode(200);
+
+        await().atMost(2, TimeUnit.SECONDS).untilAsserted(() -> {
+            List<String> records = given()
+                    .when()
+                    .get("/external-health/log-records")
+                    .then()
+                    .statusCode(200)
+                    .extract()
+                    .body()
+                    .jsonPath()
+                    .getList(".", String.class);
+
+            assertThat("Should have at least 2 log records", records.size(), greaterThanOrEqualTo(2));
+
+            boolean hasHealthCheck1Log = records.stream()
+                    .anyMatch(record -> record.contains("endpoint_context=value-from-endpoint-MdcPropagationHealthCheck1")
+                            && record.contains("Test log with MDC"));
+
+            boolean hasHealthCheck2Log = records.stream()
+                    .anyMatch(record -> record.contains("endpoint_context=value-from-endpoint-MdcPropagationHealthCheck2")
+                            && record.contains("Test log with MDC"));
+
+            assertThat("Should have log from MdcPropagationHealthCheck1 with correct MDC",
+                    hasHealthCheck1Log, is(true));
+            assertThat("Should have log from MdcPropagationHealthCheck2 with correct MDC",
+                    hasHealthCheck2Log, is(true));
+
+            records.forEach(record -> {
+                if (record.contains("MdcPropagationHealthCheck1")) {
+                    assertThat("HC1 log should not contain HC2 context",
+                            record.contains("MdcPropagationHealthCheck2"), is(false));
+                }
+                if (record.contains("MdcPropagationHealthCheck2")) {
+                    assertThat("HC2 log should not contain HC1 context",
+                            record.contains("MdcPropagationHealthCheck1"), is(false));
+                }
+            });
+        });
+    }
+
+}