Implement multiple tracing headers when using OpenTelemetry

Author: mhalbritter

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/tracing/CompositeTextMapPropagator.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2012-2023 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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.actuate.autoconfigure.tracing;
+
+import java.util.Collection;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.propagation.TextMapGetter;
+import io.opentelemetry.context.propagation.TextMapPropagator;
+import io.opentelemetry.context.propagation.TextMapSetter;
+
+/**
+ * {@link TextMapPropagator} which supports multiple tracing formats. It is able to
+ * configure different formats for injecting and for extracting.
+ *
+ * @author Moritz Halbritter
+ */
+class CompositeTextMapPropagator implements TextMapPropagator {
+
+	private final Iterable<TextMapPropagator> injectors;
+
+	private final Iterable<TextMapPropagator> extractors;
+
+	CompositeTextMapPropagator(Iterable<TextMapPropagator> injectors, Iterable<TextMapPropagator> extractors) {
+		this.injectors = injectors;
+		this.extractors = extractors;
+	}
+
+	@Override
+	public Collection<String> fields() {
+		return Stream.concat(stream(this.injectors), stream(this.extractors))
+			.flatMap((entry) -> entry.fields().stream())
+			.collect(Collectors.toSet());
+	}
+
+	@Override
+	public <C> void inject(Context context, C carrier, TextMapSetter<C> setter) {
+		if (context == null || setter == null) {
+			return;
+		}
+		for (TextMapPropagator injector : this.injectors) {
+			injector.inject(context, carrier, setter);
+		}
+	}
+
+	@Override
+	public <C> Context extract(Context context, C carrier, TextMapGetter<C> getter) {
+		if (context == null) {
+			return Context.root();
+		}
+		if (getter == null) {
+			return context;
+		}
+		for (TextMapPropagator extractor : this.extractors) {
+			Context extractedContext = extractor.extract(context, carrier, getter);
+			if (extractedContext != context) {
+				return extractedContext;
+			}
+		}
+		return context;
+	}
+
+	private static <T> Stream<T> stream(Iterable<T> iterable) {
+		return StreamSupport.stream(iterable.spliterator(), false);
+	}
+
+}

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/tracing/OpenTelemetryAutoConfiguration.java

@@ -16,6 +16,8 @@
 
 package org.springframework.boot.actuate.autoconfigure.tracing;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
@@ -52,6 +54,7 @@
 
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.SpringBootVersion;
+import org.springframework.boot.actuate.autoconfigure.tracing.TracingProperties.Propagation.PropagationType;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
@@ -66,6 +69,7 @@
  * {@link EnableAutoConfiguration Auto-configuration} for OpenTelemetry.
  *
  * @author Moritz Halbritter
+ * @author Marcin Grzejszczak
  * @since 3.0.0
  */
 @AutoConfiguration(before = MicrometerTracingAutoConfiguration.class)
@@ -185,22 +189,17 @@ static class BaggageConfiguration {
 		}
 
 		@Bean
-		@ConditionalOnProperty(prefix = "management.tracing.propagation", name = "type", havingValue = "W3C",
-				matchIfMissing = true)
-		TextMapPropagator w3cTextMapPropagatorWithBaggage(OtelCurrentTraceContext otelCurrentTraceContext) {
+		TextMapPropagator textMapPropagatorWithBaggage(OtelCurrentTraceContext otelCurrentTraceContext) {
 			List<String> remoteFields = this.tracingProperties.getBaggage().getRemoteFields();
-			return TextMapPropagator.composite(W3CTraceContextPropagator.getInstance(),
-					W3CBaggagePropagator.getInstance(), new BaggageTextMapPropagator(remoteFields,
-							new OtelBaggageManager(otelCurrentTraceContext, remoteFields, Collections.emptyList())));
-		}
-
-		@Bean
-		@ConditionalOnProperty(prefix = "management.tracing.propagation", name = "type", havingValue = "B3")
-		TextMapPropagator b3BaggageTextMapPropagator(OtelCurrentTraceContext otelCurrentTraceContext) {
-			List<String> remoteFields = this.tracingProperties.getBaggage().getRemoteFields();
-			return TextMapPropagator.composite(B3Propagator.injectingSingleHeader(),
-					new BaggageTextMapPropagator(remoteFields,
-							new OtelBaggageManager(otelCurrentTraceContext, remoteFields, Collections.emptyList())));
+			BaggageTextMapPropagator baggagePropagator = new BaggageTextMapPropagator(remoteFields,
+					new OtelBaggageManager(otelCurrentTraceContext, remoteFields, Collections.emptyList()));
+			List<TextMapPropagator> injectors = new ArrayList<>(
+					TextMapPropagatorFactory.forTypes(this.tracingProperties.getPropagation().getType(), true));
+			injectors.add(baggagePropagator);
+			List<TextMapPropagator> extractors = new ArrayList<>(
+					TextMapPropagatorFactory.forTypes(PropagationType.orderedValues(), true));
+			extractors.add(baggagePropagator);
+			return new CompositeTextMapPropagator(injectors, extractors);
 		}
 
 		@Bean
@@ -218,18 +217,12 @@ Slf4JBaggageEventListener otelSlf4JBaggageEventListener() {
 	static class NoBaggageConfiguration {
 
 		@Bean
-		@ConditionalOnMissingBean
-		@ConditionalOnProperty(prefix = "management.tracing.propagation", name = "type", havingValue = "B3")
-		B3Propagator b3TextMapPropagator() {
-			return B3Propagator.injectingSingleHeader();
-		}
-
-		@Bean
-		@ConditionalOnMissingBean
-		@ConditionalOnProperty(prefix = "management.tracing.propagation", name = "type", havingValue = "W3C",
-				matchIfMissing = true)
-		W3CTraceContextPropagator w3cTextMapPropagatorWithoutBaggage() {
-			return W3CTraceContextPropagator.getInstance();
+		TextMapPropagator textMapPropagator(TracingProperties properties) {
+			List<TextMapPropagator> injectors = TextMapPropagatorFactory.forTypes(properties.getPropagation().getType(),
+					false);
+			List<TextMapPropagator> extractors = TextMapPropagatorFactory.forTypes(PropagationType.orderedValues(),
+					false);
+			return new CompositeTextMapPropagator(injectors, extractors);
 		}
 
 	}
@@ -251,4 +244,59 @@ public void publishEvent(Object event) {
 
 	}
 
+	/**
+	 * Factory for {@link TextMapPropagator TextMapPropagators}.
+	 */
+	private static final class TextMapPropagatorFactory {
+
+		private TextMapPropagatorFactory() {
+		}
+
+		/**
+		 * Creates a new B3 propagator using a single B3 header.
+		 * @return the B3 propagator
+		 */
+		private static TextMapPropagator b3Single() {
+			return B3Propagator.injectingSingleHeader();
+		}
+
+		/**
+		 * Creates a new B3 propagator using multiple B3 headers.
+		 * @return the B3 propagator
+		 */
+		private static TextMapPropagator b3Multi() {
+			return B3Propagator.injectingMultiHeaders();
+		}
+
+		/**
+		 * Creates a new W3C propagator.
+		 * @param baggage whether baggage propagation should be supported
+		 * @return the W3C propagator
+		 */
+		private static TextMapPropagator w3c(boolean baggage) {
+			if (!baggage) {
+				return W3CTraceContextPropagator.getInstance();
+			}
+			return TextMapPropagator.composite(W3CTraceContextPropagator.getInstance(),
+					W3CBaggagePropagator.getInstance());
+		}
+
+		private static TextMapPropagator forType(PropagationType type, boolean baggage) {
+			return switch (type) {
+				case B3 -> b3Single();
+				case B3_MULTI -> b3Multi();
+				case W3C -> w3c(baggage);
+			};
+		}
+
+		private static List<TextMapPropagator> forTypes(Collection<PropagationType> types, boolean baggage) {
+			List<TextMapPropagator> result = new ArrayList<>(types.size());
+			for (PropagationType type : types) {
+				result.add(forType(type, baggage));
+			}
+			return result;
+		}
+
+	}
+
 }