Fix Slf4jThreadLocalAccessor with keys for missing values

In case of missing MDC entries, when a scope was closed, the value
should be removed. This was not the case and that could lead to leaks of
these MDC entries. This change takes the missing previous values into
account and clears them from the MDC in case they were set by a
snapshot.

Fixes #347.

Signed-off-by: Dariusz Jędrzejczyk <[email protected]>

Author: chemicL

context-propagation/src/main/java/io/micrometer/context/integration/Slf4jThreadLocalAccessor.java

@@ -1,5 +1,5 @@
 /**
- * Copyright 2024 the original author or authors.
+ * Copyright 2024-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -127,6 +127,9 @@ public void setValue(Map<String, String> value) {
                 if (mdcValue != null) {
                     MDC.put(key, mdcValue);
                 }
+                else {
+                    MDC.remove(key);
+                }
             }
         }
 

context-propagation/src/test/java/io/micrometer/context/integration/Slf4jThreadLocalAccessorTests.java

@@ -1,5 +1,5 @@
 /**
- * Copyright 2024 the original author or authors.
+ * Copyright 2024-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -106,4 +106,67 @@ void shouldCopySelectedMdcContentsToNewThread() throws InterruptedException {
         executorService.shutdown();
     }
 
+    @Test
+    void shouldDealWithEmptySelectedValues() throws InterruptedException {
+        ContextRegistry registry = new ContextRegistry()
+            .registerThreadLocalAccessor(new Slf4jThreadLocalAccessor("key1", "key2"));
+
+        ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+        CountDownLatch latch = new CountDownLatch(1);
+        AtomicReference<String> value1InOtherThread = new AtomicReference<>();
+        AtomicReference<String> value2InOtherThread = new AtomicReference<>();
+        AtomicReference<String> value3InOtherThread = new AtomicReference<>();
+
+        MDC.put("key1", "value1_1");
+        MDC.put("key3", "value3_1");
+
+        ContextSnapshot snapshot = ContextSnapshotFactory.builder()
+            .contextRegistry(registry)
+            .clearMissing(true)
+            .build()
+            .captureAll();
+
+        executorService.submit(() -> {
+            try (ContextSnapshot.Scope scope = snapshot.setThreadLocals()) {
+                value1InOtherThread.set(MDC.get("key1"));
+                value2InOtherThread.set(MDC.get("key2"));
+                value3InOtherThread.set(MDC.get("key3"));
+            }
+            latch.countDown();
+        });
+
+        latch.await(100, TimeUnit.MILLISECONDS);
+
+        assertThat(value1InOtherThread.get()).isEqualTo("value1_1");
+        assertThat(value2InOtherThread.get()).isNull();
+        assertThat(value3InOtherThread.get()).isNull();
+
+        CountDownLatch latch2 = new CountDownLatch(1);
+
+        MDC.remove("key1");
+        MDC.put("key2", "value2_2");
+
+        ContextSnapshot snapshot2 = ContextSnapshotFactory.builder()
+            .contextRegistry(registry)
+            .clearMissing(true)
+            .build()
+            .captureAll();
+        executorService.submit(() -> {
+            try (ContextSnapshot.Scope scope = snapshot2.setThreadLocals()) {
+                value1InOtherThread.set(MDC.get("key1"));
+                value2InOtherThread.set(MDC.get("key2"));
+                value3InOtherThread.set(MDC.get("key3"));
+            }
+            latch2.countDown();
+        });
+
+        latch2.await(100, TimeUnit.MILLISECONDS);
+
+        assertThat(value1InOtherThread.get()).isNull();
+        assertThat(value2InOtherThread.get()).isEqualTo("value2_2");
+        assertThat(value3InOtherThread.get()).isNull();
+        executorService.shutdown();
+    }
+
 }