Merge branch '1.4.x' into 1.5.x

Author: shakuzen

micrometer-tracing-bridges/micrometer-tracing-bridge-otel/src/main/java/io/micrometer/tracing/otel/propagation/BaggageTextMapPropagator.java

@@ -15,6 +15,7 @@
  */
 package io.micrometer.tracing.otel.propagation;
 
+import io.micrometer.common.lang.Nullable;
 import io.micrometer.common.util.internal.logging.InternalLogger;
 import io.micrometer.common.util.internal.logging.InternalLoggerFactory;
 import io.micrometer.tracing.BaggageManager;
@@ -26,9 +27,10 @@
 import io.opentelemetry.context.propagation.TextMapPropagator;
 import io.opentelemetry.context.propagation.TextMapSetter;
 
-import java.util.AbstractMap;
+import java.util.AbstractMap.SimpleEntry;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.stream.Collectors;
 
 /**
@@ -84,22 +86,27 @@ private <C> List<Map.Entry<String, String>> applicableBaggageEntries(C c) {
     }
 
     @Override
-    public <C> Context extract(Context context, C c, TextMapGetter<C> getter) {
-        Map<String, String> baggageEntries = this.remoteFields.stream()
-            .map(s -> new AbstractMap.SimpleEntry<>(s, getter.get(c, s)))
+    public <C> Context extract(Context context, @Nullable C carrier, TextMapGetter<C> getter) {
+        BaggageBuilder newBaggage = Baggage.fromContext(context).toBuilder();
+
+        Map<String, String> carierEntries = extractFromCarrier(carrier, getter);
+        carierEntries
+            .forEach((key, value) -> newBaggage.put(key, value, BaggageEntryMetadata.create(PROPAGATION_UNLIMITED)));
+
+        return context.with(newBaggage.build());
+    }
+
+    private <C> Map<String, String> extractFromCarrier(@Nullable C carrier, TextMapGetter<C> getter) {
+        Map<String, String> carierEntries = this.remoteFields.stream()
+            .map(s -> new SimpleEntry<>(s, getter.get(carrier, s)))
             .filter(e -> e.getValue() != null)
-            .collect(Collectors.toMap((e) -> e.getKey(), (e) -> e.getValue()));
-        BaggageBuilder builder = Baggage.current().toBuilder();
-        baggageEntries
-            .forEach((key, value) -> builder.put(key, value, BaggageEntryMetadata.create(PROPAGATION_UNLIMITED)));
-        Baggage.fromContext(context)
-            .forEach((s, baggageEntry) -> builder.put(s, baggageEntry.getValue(), baggageEntry.getMetadata()));
-        Baggage baggage = builder.build();
-        Context withBaggage = context.with(baggage);
+            .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
+
         if (log.isDebugEnabled()) {
-            log.debug("Will propagate new baggage context for entries " + baggageEntries);
+            log.debug("Will propagate new baggage context for entries " + carierEntries);
         }
-        return withBaggage;
+
+        return carierEntries;
     }
 
 }

micrometer-tracing-bridges/micrometer-tracing-bridge-otel/src/test/java/io/micrometer/tracing/otel/propagation/BaggageTextMapPropagatorTests.java

@@ -22,24 +22,70 @@
 import io.opentelemetry.context.Context;
 import io.opentelemetry.context.propagation.TextMapGetter;
 import org.assertj.core.api.BDDAssertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import java.util.*;
 
+import static java.util.Collections.emptyList;
+
 class BaggageTextMapPropagatorTests {
 
+    private static final List<String> REMOTE_FIELDS = Arrays.asList("foo", "foo2");
+
+    private BaggageTextMapPropagator baggageTextMapPropagator;
+
+    private TextMapGetter<Map<String, String>> textMapGetter;
+
+    @BeforeEach
+    void setup() {
+        baggageTextMapPropagator = new BaggageTextMapPropagator(REMOTE_FIELDS,
+                new OtelBaggageManager(new OtelCurrentTraceContext(), REMOTE_FIELDS, emptyList()));
+        textMapGetter = textMapGetter(REMOTE_FIELDS);
+    }
+
     @Test
     void should_append_baggage_to_existing_one() {
-        Baggage baggage = Baggage.current().toBuilder().put("foo", "bar").put("baz", "baz2").build();
-        Context parent = Context.current().with(baggage);
-        List<String> remoteFields = Arrays.asList("foo", "foo2");
-        BaggageTextMapPropagator baggageTextMapPropagator = new BaggageTextMapPropagator(remoteFields,
-                new OtelBaggageManager(new OtelCurrentTraceContext(), remoteFields, Collections.emptyList()));
+        Baggage baggage = Baggage.empty().toBuilder().put("foo", "undesired").put("lorem", "ipsum").build();
+        Context parent = Context.root().with(baggage);
+
         Map<String, String> carrier = new HashMap<>();
         carrier.put("foo", "bar");
         carrier.put("foo2", "bar2");
 
-        Context extracted = baggageTextMapPropagator.extract(parent, carrier, new TextMapGetter<Map<String, String>>() {
+        Context extracted = baggageTextMapPropagator.extract(parent, carrier, textMapGetter);
+
+        Map<String, BaggageEntry> extractedBaggage = Baggage.fromContext(extracted).asMap();
+        BDDAssertions.then(extractedBaggage).containsOnlyKeys("foo", "foo2", "lorem");
+
+        BDDAssertions.then(extractedBaggage.get("foo").getValue()).isEqualTo("bar");
+        BDDAssertions.then(extractedBaggage.get("foo2").getValue()).isEqualTo("bar2");
+        BDDAssertions.then(extractedBaggage.get("lorem").getValue()).isEqualTo("ipsum");
+    }
+
+    @Test
+    void should_not_mix_baggage_with_current_baggage() {
+        Baggage currentBaggage = Baggage.empty()
+            .toBuilder()
+            .put("current-key", "undesired")
+            .put("foo", "undesired")
+            .build();
+        Context currentContext = Context.root().with(currentBaggage);
+
+        Context extracted = currentContext.wrapSupplier(() -> {
+            Map<String, String> carrier = new HashMap<>();
+            carrier.put("foo", "bar");
+
+            return baggageTextMapPropagator.extract(Context.root(), carrier, textMapGetter(REMOTE_FIELDS));
+        }).get();
+
+        Map<String, BaggageEntry> extractedBaggage = Baggage.fromContext(extracted).asMap();
+        BDDAssertions.then(extractedBaggage).doesNotContainKey("current-key");
+        BDDAssertions.then(extractedBaggage.get("foo").getValue()).isEqualTo("bar");
+    }
+
+    private TextMapGetter<Map<String, String>> textMapGetter(final List<String> remoteFields) {
+        return new TextMapGetter<Map<String, String>>() {
             @Override
             public Iterable<String> keys(Map<String, String> carrier) {
                 return remoteFields;
@@ -49,10 +95,7 @@ public Iterable<String> keys(Map<String, String> carrier) {
             public String get(Map<String, String> carrier, String key) {
                 return carrier.get(key);
             }
-        });
-
-        Map<String, BaggageEntry> newBaggage = Baggage.fromContext(extracted).asMap();
-        BDDAssertions.then(newBaggage).containsOnlyKeys("foo", "foo2", "baz");
+        };
     }
 
 }