Merge branch 'main' into fix-mdc-propagation

Author: merlimat

src/main/java/io/github/merlimat/slog/Event.java

@@ -107,6 +107,35 @@ public interface Event {
      */
     Event attr(String key, ThrowingSupplier<?> value);
 
+    /**
+     * Inherits the context attributes from another logger for this event only.
+     * Useful when the current logger is a static/shared instance but you want
+     * to attach the context of a request- or component-scoped logger without
+     * allocating a new child logger.
+     *
+     * <p>Ordering mirrors {@link LoggerBuilder#ctx}: the inherited attrs are
+     * placed <i>before</i> the current logger's own context, followed by the
+     * per-event attrs. Multiple calls append in invocation order.
+     *
+     * <pre>{@code
+     * static final Logger log = Logger.get(MyService.class);
+     *
+     * void handle(Logger requestLog, String msgId) {
+     *     log.info()
+     *         .ctx(requestLog)          // adopt request-scoped context
+     *         .attr("msgId", msgId)
+     *         .log("processed");
+     * }
+     * }</pre>
+     *
+     * <p>Allocation-free when the current logger has no context of its own
+     * (the common static-logger case).
+     *
+     * @param other the logger whose context to inherit
+     * @return this event, for chaining
+     */
+    Event ctx(Logger other);
+
     /**
      * Attaches an exception to this event, including the full stack trace.
      * No-op if {@code t} is {@code null}.

src/main/java/io/github/merlimat/slog/impl/EventImpl.java

@@ -16,6 +16,7 @@
 package io.github.merlimat.slog.impl;
 
 import io.github.merlimat.slog.Event;
+import io.github.merlimat.slog.Logger;
 import io.github.merlimat.slog.ThrowingSupplier;
 import java.time.Clock;
 import java.time.Duration;
@@ -35,6 +36,7 @@ final class EventImpl implements Event {
     private int attrCount;
     private Throwable throwable;
     private Instant startTime;
+    private AttrChain extraContext = AttrChain.EMPTY;
 
     EventImpl(BaseLogger logger, Level level, Clock clock) {
         this.logger = logger;
@@ -88,6 +90,15 @@ public Event attr(String key, ThrowingSupplier<?> value) {
         return attr(key, (Object) value);
     }
 
+    @Override
+    public Event ctx(Logger other) {
+        AttrChain otherCtx = ((BaseLogger) other).contextAttrs();
+        if (!otherCtx.isEmpty()) {
+            extraContext = otherCtx.withPrefix(extraContext);
+        }
+        return this;
+    }
+
     @Override
     public Event exception(Throwable t) {
         if (t != null) {
@@ -161,8 +172,12 @@ private void emit(String msg) {
                 ? Duration.between(startTime, clock.instant())
                 : null;
 
+        AttrChain contextAttrs = extraContext.isEmpty()
+                ? logger.contextAttrs()
+                : logger.contextAttrs().withPrefix(extraContext);
+
         logger.emit(logger.name(), level, msg,
-                logger.contextAttrs(),
+                contextAttrs,
                 attrKeys, attrValues, attrCount,
                 throwable, duration, FQCN);
     }

src/main/java/io/github/merlimat/slog/impl/NoopEvent.java

@@ -16,6 +16,7 @@
 package io.github.merlimat.slog.impl;
 
 import io.github.merlimat.slog.Event;
+import io.github.merlimat.slog.Logger;
 import io.github.merlimat.slog.ThrowingSupplier;
 import java.time.Duration;
 
@@ -61,6 +62,11 @@ public Event attr(String key, ThrowingSupplier<?> value) {
         return this;
     }
 
+    @Override
+    public Event ctx(Logger other) {
+        return this;
+    }
+
     @Override
     public Event exception(Throwable t) {
         return this;

src/test/java/io/github/merlimat/slog/impl/LoggerTest.java

@@ -562,6 +562,97 @@ void consumerVariantWithException() {
         assertSame(ex, r.throwable());
     }
 
+    @Test
+    void eventCtxAttachesForeignContext() {
+        Logger requestLog = TestLogger.create("request", enabledLevels, records).with()
+                .attr("requestId", "req-42")
+                .attr("traceId", "abc-123")
+                .build();
+
+        Logger log = TestLogger.create("test", enabledLevels, records);
+        log.info().ctx(requestLog).attr("msgId", "1:2:3").log("processed");
+
+        assertEquals(1, records.size());
+        LogRecord r = records.get(0);
+        // Logger name stays the static logger's name
+        assertEquals("test", r.loggerName());
+        List<Attr> a = attrs(r);
+        assertEquals(3, a.size());
+        // ctx attrs come first
+        assertEquals("requestId", a.get(0).key());
+        assertEquals("traceId", a.get(1).key());
+        // then per-event attrs
+        assertEquals("msgId", a.get(2).key());
+    }
+
+    @Test
+    void eventCtxOrderedBeforeLoggerOwnContext() {
+        Logger requestLog = TestLogger.create("request", enabledLevels, records).with()
+                .attr("requestId", "req-42")
+                .build();
+
+        Logger log = TestLogger.create("test", enabledLevels, records).with()
+                .attr("component", "worker")
+                .build();
+
+        log.info().ctx(requestLog).attr("msgId", "1:2:3").log("processed");
+
+        List<Attr> a = attrs(records.get(0));
+        assertEquals(3, a.size());
+        // ctx attrs first, then logger's own, then per-event
+        assertEquals("requestId", a.get(0).key());
+        assertEquals("component", a.get(1).key());
+        assertEquals("msgId", a.get(2).key());
+    }
+
+    @Test
+    void eventCtxWithEmptyLoggerIsNoOp() {
+        Logger empty = TestLogger.create("empty", enabledLevels, records);
+        Logger log = TestLogger.create("test", enabledLevels, records);
+
+        log.info().ctx(empty).attr("k", "v").log("msg");
+
+        List<Attr> a = attrs(records.get(0));
+        assertEquals(1, a.size());
+        assertEquals("k", a.get(0).key());
+    }
+
+    @Test
+    void eventCtxMultipleCallsAppendInOrder() {
+        Logger producerLog = TestLogger.create("producer", enabledLevels, records).with()
+                .attr("topic", "orders")
+                .build();
+        Logger requestLog = TestLogger.create("request", enabledLevels, records).with()
+                .attr("requestId", "req-42")
+                .build();
+
+        Logger log = TestLogger.create("test", enabledLevels, records);
+        log.info()
+                .ctx(producerLog)
+                .ctx(requestLog)
+                .attr("extra", "val")
+                .log("combined");
+
+        List<Attr> a = attrs(records.get(0));
+        assertEquals(3, a.size());
+        assertEquals("topic", a.get(0).key());
+        assertEquals("requestId", a.get(1).key());
+        assertEquals("extra", a.get(2).key());
+    }
+
+    @Test
+    void eventCtxOnDisabledLevelIsNoOp() {
+        Logger requestLog = TestLogger.create("request", enabledLevels, records).with()
+                .attr("requestId", "req-42")
+                .build();
+
+        Logger log = TestLogger.create("test", enabledLevels, records);
+        // DEBUG is disabled in this test setup
+        log.debug().ctx(requestLog).attr("k", "v").log("nope");
+
+        assertEquals(0, records.size());
+    }
+
     @Test
     void duplicateKeysInEventAttrs() {
         Logger log = TestLogger.create("test", enabledLevels, records).with()