diff --git a/.github/component_owners.yml b/.github/component_owners.yml
index ad0c038c5..a58e86088 100644
--- a/.github/component_owners.yml
+++ b/.github/component_owners.yml
@@ -14,6 +14,8 @@ components:
- willarmiros
aws-xray:
- willarmiros
+ aws-xray-propagator:
+ - willarmiros
consistent-sampling:
- oertl
- PeterF778
diff --git a/README.md b/README.md
index 1997cfd56..99fc777c0 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,9 @@ feature or via instrumentation, this project is hopefully for you.
## Provided Libraries
-* [AWS X-Ray Support](./aws-xray/README.md)
+* [AWS Resources](./aws-resources/README.md)
+* [AWS X-Ray SDK Support](./aws-xray/README.md)
+* [AWS X-Ray Propagator](./aws-xray-propagator/README.md)
* [Consistent sampling](./consistent-sampling/README.md)
* [JFR Streaming](./jfr-streaming/README.md)
* [JMX Metric Gatherer](./jmx-metrics/README.md)
diff --git a/aws-xray-propagator/README.md b/aws-xray-propagator/README.md
new file mode 100644
index 000000000..ee8b156f7
--- /dev/null
+++ b/aws-xray-propagator/README.md
@@ -0,0 +1,10 @@
+# OpenTelemetry AWS X-Ray Propagator
+
+This module contains a `TextMapPropagator` implementation compatible with
+the [AWS X-Ray Trace Header propagation protocol](https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-tracingheader).
+
+## Component owners
+
+- [William Armiros](https://github.com/willarmiros), AWS
+
+Learn more about component owners in [component_owners.yml](../.github/component_owners.yml).
diff --git a/aws-xray-propagator/build.gradle.kts b/aws-xray-propagator/build.gradle.kts
new file mode 100644
index 000000000..435b5509a
--- /dev/null
+++ b/aws-xray-propagator/build.gradle.kts
@@ -0,0 +1,12 @@
+plugins {
+ id("otel.java-conventions")
+
+ id("otel.publish-conventions")
+}
+
+description = "OpenTelemetry AWS X-Ray Propagator"
+
+dependencies {
+ api("io.opentelemetry:opentelemetry-api")
+ compileOnly("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure-spi")
+}
diff --git a/aws-xray-propagator/gradle.properties b/aws-xray-propagator/gradle.properties
new file mode 100644
index 000000000..a0402e1e2
--- /dev/null
+++ b/aws-xray-propagator/gradle.properties
@@ -0,0 +1,2 @@
+# TODO: uncomment when ready to mark as stable
+# otel.stable=true
diff --git a/aws-xray-propagator/src/main/java/io/opentelemetry/contrib/awsxray/propagator/AwsConfigurablePropagator.java b/aws-xray-propagator/src/main/java/io/opentelemetry/contrib/awsxray/propagator/AwsConfigurablePropagator.java
new file mode 100644
index 000000000..7027f464e
--- /dev/null
+++ b/aws-xray-propagator/src/main/java/io/opentelemetry/contrib/awsxray/propagator/AwsConfigurablePropagator.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.awsxray.propagator;
+
+import io.opentelemetry.context.propagation.TextMapPropagator;
+import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
+import io.opentelemetry.sdk.autoconfigure.spi.ConfigurablePropagatorProvider;
+
+/**
+ * A {@link ConfigurablePropagatorProvider} which allows enabling the {@link AwsXrayPropagator} with
+ * the propagator name {@code xray}.
+ */
+public final class AwsConfigurablePropagator implements ConfigurablePropagatorProvider {
+ @Override
+ public TextMapPropagator getPropagator(ConfigProperties config) {
+ return AwsXrayPropagator.getInstance();
+ }
+
+ @Override
+ public String getName() {
+ return "xray";
+ }
+}
diff --git a/aws-xray-propagator/src/main/java/io/opentelemetry/contrib/awsxray/propagator/AwsXrayPropagator.java b/aws-xray-propagator/src/main/java/io/opentelemetry/contrib/awsxray/propagator/AwsXrayPropagator.java
new file mode 100644
index 000000000..2ce17875b
--- /dev/null
+++ b/aws-xray-propagator/src/main/java/io/opentelemetry/contrib/awsxray/propagator/AwsXrayPropagator.java
@@ -0,0 +1,329 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.awsxray.propagator;
+
+import io.opentelemetry.api.baggage.Baggage;
+import io.opentelemetry.api.baggage.BaggageBuilder;
+import io.opentelemetry.api.baggage.BaggageEntry;
+import io.opentelemetry.api.internal.StringUtils;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.SpanId;
+import io.opentelemetry.api.trace.TraceFlags;
+import io.opentelemetry.api.trace.TraceId;
+import io.opentelemetry.api.trace.TraceState;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.propagation.TextMapGetter;
+import io.opentelemetry.context.propagation.TextMapPropagator;
+import io.opentelemetry.context.propagation.TextMapSetter;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Implementation of the AWS X-Ray Trace Header propagation protocol. See AWS
+ * Tracing header spec
+ *
+ * To register the X-Ray propagator together with default propagator when using the SDK:
+ *
+ *
{@code
+ * OpenTelemetrySdk.builder()
+ * .setPropagators(
+ * ContextPropagators.create(
+ * TextMapPropagator.composite(
+ * W3CTraceContextPropagator.getInstance(),
+ * AWSXrayPropagator.getInstance())))
+ * .build();
+ * }
+ */
+public final class AwsXrayPropagator implements TextMapPropagator {
+
+ // Visible for testing
+ static final String TRACE_HEADER_KEY = "X-Amzn-Trace-Id";
+
+ private static final Logger logger = Logger.getLogger(AwsXrayPropagator.class.getName());
+
+ private static final char TRACE_HEADER_DELIMITER = ';';
+ private static final char KV_DELIMITER = '=';
+
+ private static final String TRACE_ID_KEY = "Root";
+ private static final int TRACE_ID_LENGTH = 35;
+ private static final String TRACE_ID_VERSION = "1";
+ private static final char TRACE_ID_DELIMITER = '-';
+ private static final int TRACE_ID_DELIMITER_INDEX_1 = 1;
+ private static final int TRACE_ID_DELIMITER_INDEX_2 = 10;
+ private static final int TRACE_ID_FIRST_PART_LENGTH = 8;
+
+ private static final String PARENT_ID_KEY = "Parent";
+ private static final int PARENT_ID_LENGTH = 16;
+
+ private static final String SAMPLED_FLAG_KEY = "Sampled";
+ private static final int SAMPLED_FLAG_LENGTH = 1;
+ private static final char IS_SAMPLED = '1';
+ private static final char NOT_SAMPLED = '0';
+
+ private static final List FIELDS = Collections.singletonList(TRACE_HEADER_KEY);
+
+ private static final AwsXrayPropagator INSTANCE = new AwsXrayPropagator();
+
+ private AwsXrayPropagator() {
+ // singleton
+ }
+
+ public static AwsXrayPropagator getInstance() {
+ return INSTANCE;
+ }
+
+ @Override
+ public List fields() {
+ return FIELDS;
+ }
+
+ @Override
+ public void inject(Context context, @Nullable C carrier, TextMapSetter setter) {
+ if (context == null) {
+ return;
+ }
+ if (setter == null) {
+ return;
+ }
+
+ Span span = Span.fromContext(context);
+ if (!span.getSpanContext().isValid()) {
+ return;
+ }
+
+ SpanContext spanContext = span.getSpanContext();
+
+ String otTraceId = spanContext.getTraceId();
+ String xrayTraceId =
+ TRACE_ID_VERSION
+ + TRACE_ID_DELIMITER
+ + otTraceId.substring(0, TRACE_ID_FIRST_PART_LENGTH)
+ + TRACE_ID_DELIMITER
+ + otTraceId.substring(TRACE_ID_FIRST_PART_LENGTH);
+ String parentId = spanContext.getSpanId();
+ char samplingFlag = spanContext.isSampled() ? IS_SAMPLED : NOT_SAMPLED;
+ // TODO: Add OT trace state to the X-Ray trace header
+
+ StringBuilder traceHeader = new StringBuilder();
+ traceHeader
+ .append(TRACE_ID_KEY)
+ .append(KV_DELIMITER)
+ .append(xrayTraceId)
+ .append(TRACE_HEADER_DELIMITER)
+ .append(PARENT_ID_KEY)
+ .append(KV_DELIMITER)
+ .append(parentId)
+ .append(TRACE_HEADER_DELIMITER)
+ .append(SAMPLED_FLAG_KEY)
+ .append(KV_DELIMITER)
+ .append(samplingFlag);
+
+ Baggage baggage = Baggage.fromContext(context);
+ // Truncate baggage to 256 chars per X-Ray spec.
+ baggage.forEach(
+ new BiConsumer() {
+
+ private int baggageWrittenBytes;
+
+ @Override
+ public void accept(String key, BaggageEntry entry) {
+ if (key.equals(TRACE_ID_KEY)
+ || key.equals(PARENT_ID_KEY)
+ || key.equals(SAMPLED_FLAG_KEY)) {
+ return;
+ }
+ // Size is key/value pair, excludes delimiter.
+ int size = key.length() + entry.getValue().length() + 1;
+ if (baggageWrittenBytes + size > 256) {
+ return;
+ }
+ traceHeader
+ .append(TRACE_HEADER_DELIMITER)
+ .append(key)
+ .append(KV_DELIMITER)
+ .append(entry.getValue());
+ baggageWrittenBytes += size;
+ }
+ });
+
+ setter.set(carrier, TRACE_HEADER_KEY, traceHeader.toString());
+ }
+
+ @Override
+ public Context extract(Context context, @Nullable C carrier, TextMapGetter getter) {
+ if (context == null) {
+ return Context.root();
+ }
+ if (getter == null) {
+ return context;
+ }
+
+ return getContextFromHeader(context, carrier, getter);
+ }
+
+ private static Context getContextFromHeader(
+ Context context, @Nullable C carrier, TextMapGetter getter) {
+ String traceHeader = getter.get(carrier, TRACE_HEADER_KEY);
+ if (traceHeader == null || traceHeader.isEmpty()) {
+ return context;
+ }
+
+ String traceId = TraceId.getInvalid();
+ String spanId = SpanId.getInvalid();
+ Boolean isSampled = false;
+
+ BaggageBuilder baggage = null;
+ int baggageReadBytes = 0;
+
+ int pos = 0;
+ while (pos < traceHeader.length()) {
+ int delimiterIndex = traceHeader.indexOf(TRACE_HEADER_DELIMITER, pos);
+ String part;
+ if (delimiterIndex >= 0) {
+ part = traceHeader.substring(pos, delimiterIndex);
+ pos = delimiterIndex + 1;
+ } else {
+ // Last part.
+ part = traceHeader.substring(pos);
+ pos = traceHeader.length();
+ }
+ String trimmedPart = part.trim();
+ int equalsIndex = trimmedPart.indexOf(KV_DELIMITER);
+ if (equalsIndex < 0) {
+ logger.fine("Error parsing X-Ray trace header. Invalid key value pair: " + part);
+ return context;
+ }
+
+ String value = trimmedPart.substring(equalsIndex + 1);
+
+ if (trimmedPart.startsWith(TRACE_ID_KEY)) {
+ traceId = parseTraceId(value);
+ } else if (trimmedPart.startsWith(PARENT_ID_KEY)) {
+ spanId = parseSpanId(value);
+ } else if (trimmedPart.startsWith(SAMPLED_FLAG_KEY)) {
+ isSampled = parseTraceFlag(value);
+ } else if (baggageReadBytes + trimmedPart.length() <= 256) {
+ if (baggage == null) {
+ baggage = Baggage.builder();
+ }
+ baggage.put(trimmedPart.substring(0, equalsIndex), value);
+ baggageReadBytes += trimmedPart.length();
+ }
+ }
+ if (isSampled == null) {
+ logger.fine(
+ "Invalid Sampling flag in X-Ray trace header: '"
+ + TRACE_HEADER_KEY
+ + "' with value "
+ + traceHeader
+ + "'.");
+ return context;
+ }
+
+ if (spanId == null || traceId == null) {
+ logger.finest("Both traceId and spanId are required to extract a valid span context. ");
+ }
+
+ SpanContext spanContext =
+ SpanContext.createFromRemoteParent(
+ StringUtils.padLeft(traceId, TraceId.getLength()),
+ spanId,
+ isSampled ? TraceFlags.getSampled() : TraceFlags.getDefault(),
+ TraceState.getDefault());
+ if (spanContext.isValid()) {
+ context = context.with(Span.wrap(spanContext));
+ }
+ if (baggage != null) {
+ context = context.with(baggage.build());
+ }
+ return context;
+ }
+
+ private static String parseTraceId(String xrayTraceId) {
+ return (xrayTraceId.length() == TRACE_ID_LENGTH
+ ? parseSpecTraceId(xrayTraceId)
+ : parseShortTraceId(xrayTraceId));
+ }
+
+ private static String parseSpecTraceId(String xrayTraceId) {
+
+ // Check version trace id version
+ if (!xrayTraceId.startsWith(TRACE_ID_VERSION)) {
+ return TraceId.getInvalid();
+ }
+
+ // Check delimiters
+ if (xrayTraceId.charAt(TRACE_ID_DELIMITER_INDEX_1) != TRACE_ID_DELIMITER
+ || xrayTraceId.charAt(TRACE_ID_DELIMITER_INDEX_2) != TRACE_ID_DELIMITER) {
+ return TraceId.getInvalid();
+ }
+
+ String epochPart =
+ xrayTraceId.substring(TRACE_ID_DELIMITER_INDEX_1 + 1, TRACE_ID_DELIMITER_INDEX_2);
+ String uniquePart = xrayTraceId.substring(TRACE_ID_DELIMITER_INDEX_2 + 1, TRACE_ID_LENGTH);
+
+ // X-Ray trace id format is 1-{8 digit hex}-{24 digit hex}
+ return epochPart + uniquePart;
+ }
+
+ private static String parseShortTraceId(String xrayTraceId) {
+ if (xrayTraceId.length() > TRACE_ID_LENGTH) {
+ return TraceId.getInvalid();
+ }
+
+ // Check version trace id version
+ if (!xrayTraceId.startsWith(TRACE_ID_VERSION)) {
+ return TraceId.getInvalid();
+ }
+
+ // Check delimiters
+ int firstDelimiter = xrayTraceId.indexOf(TRACE_ID_DELIMITER);
+ // we don't allow the epoch part to be missing completely
+ int secondDelimiter = xrayTraceId.indexOf(TRACE_ID_DELIMITER, firstDelimiter + 2);
+ if (firstDelimiter != TRACE_ID_DELIMITER_INDEX_1
+ || secondDelimiter == -1
+ || secondDelimiter > TRACE_ID_DELIMITER_INDEX_2) {
+ return TraceId.getInvalid();
+ }
+
+ String epochPart = xrayTraceId.substring(firstDelimiter + 1, secondDelimiter);
+ String uniquePart = xrayTraceId.substring(secondDelimiter + 1, secondDelimiter + 25);
+
+ // X-Ray trace id format is 1-{at most 8 digit hex}-{24 digit hex}
+ // epoch part can have leading 0s truncated
+ return epochPart + uniquePart;
+ }
+
+ private static String parseSpanId(String xrayParentId) {
+ if (xrayParentId.length() != PARENT_ID_LENGTH) {
+ return SpanId.getInvalid();
+ }
+
+ return xrayParentId;
+ }
+
+ @Nullable
+ private static Boolean parseTraceFlag(String xraySampledFlag) {
+ if (xraySampledFlag.length() != SAMPLED_FLAG_LENGTH) {
+ // Returning null as there is no invalid trace flag defined.
+ return null;
+ }
+
+ char flag = xraySampledFlag.charAt(0);
+ if (flag == IS_SAMPLED) {
+ return true;
+ } else if (flag == NOT_SAMPLED) {
+ return false;
+ } else {
+ return null;
+ }
+ }
+}
diff --git a/aws-xray-propagator/src/main/java/io/opentelemetry/contrib/awsxray/propagator/package-info.java b/aws-xray-propagator/src/main/java/io/opentelemetry/contrib/awsxray/propagator/package-info.java
new file mode 100644
index 000000000..ee9b359df
--- /dev/null
+++ b/aws-xray-propagator/src/main/java/io/opentelemetry/contrib/awsxray/propagator/package-info.java
@@ -0,0 +1,5 @@
+/** OpenTelemetry AWS X-Ray propagator extension. */
+@ParametersAreNonnullByDefault
+package io.opentelemetry.contrib.awsxray.propagator;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/aws-xray-propagator/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ConfigurablePropagatorProvider b/aws-xray-propagator/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ConfigurablePropagatorProvider
new file mode 100644
index 000000000..95ace8d1c
--- /dev/null
+++ b/aws-xray-propagator/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ConfigurablePropagatorProvider
@@ -0,0 +1 @@
+io.opentelemetry.contrib.awsxray.propagator.AwsConfigurablePropagator
diff --git a/aws-xray-propagator/src/test/java/io/opentelemetry/contrib/awsxray/propagator/AwsXrayPropagatorTest.java b/aws-xray-propagator/src/test/java/io/opentelemetry/contrib/awsxray/propagator/AwsXrayPropagatorTest.java
new file mode 100644
index 000000000..452c7c1bd
--- /dev/null
+++ b/aws-xray-propagator/src/test/java/io/opentelemetry/contrib/awsxray/propagator/AwsXrayPropagatorTest.java
@@ -0,0 +1,477 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.awsxray.propagator;
+
+import static io.opentelemetry.contrib.awsxray.propagator.AwsXrayPropagator.TRACE_HEADER_KEY;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.opentelemetry.api.baggage.Baggage;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.TraceFlags;
+import io.opentelemetry.api.trace.TraceState;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.propagation.TextMapGetter;
+import io.opentelemetry.context.propagation.TextMapSetter;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Nullable;
+import org.junit.jupiter.api.Test;
+
+class AwsXrayPropagatorTest {
+
+ private static final String TRACE_ID = "8a3c60f7d188f8fa79d48a391a778fa6";
+ private static final String SPAN_ID = "53995c3f42cd8ad8";
+
+ private static final TextMapSetter> setter = Map::put;
+ private static final TextMapGetter> getter =
+ new TextMapGetter>() {
+ @Override
+ public Set keys(Map carrier) {
+ return carrier.keySet();
+ }
+
+ @Nullable
+ @Override
+ public String get(Map carrier, String key) {
+ return carrier.get(key);
+ }
+ };
+ private final AwsXrayPropagator xrayPropagator = AwsXrayPropagator.getInstance();
+
+ @Test
+ void inject_SampledContext() {
+ Map carrier = new LinkedHashMap<>();
+ xrayPropagator.inject(
+ withSpanContext(
+ SpanContext.create(TRACE_ID, SPAN_ID, TraceFlags.getSampled(), TraceState.getDefault()),
+ Context.current()),
+ carrier,
+ setter);
+
+ assertThat(carrier)
+ .containsEntry(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=1");
+ }
+
+ @Test
+ void inject_NotSampledContext() {
+ Map carrier = new LinkedHashMap<>();
+ xrayPropagator.inject(
+ withSpanContext(
+ SpanContext.create(TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TraceState.getDefault()),
+ Context.current()),
+ carrier,
+ setter);
+
+ assertThat(carrier)
+ .containsEntry(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=0");
+ }
+
+ @Test
+ void inject_WithBaggage() {
+ Map carrier = new LinkedHashMap<>();
+ xrayPropagator.inject(
+ withSpanContext(
+ SpanContext.create(
+ TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TraceState.getDefault()),
+ Context.current())
+ .with(
+ Baggage.builder()
+ .put("cat", "meow")
+ .put("dog", "bark")
+ .put("Root", "ignored")
+ .put("Parent", "ignored")
+ .put("Sampled", "ignored")
+ .build()),
+ carrier,
+ setter);
+
+ assertThat(carrier)
+ .containsEntry(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=0;"
+ + "cat=meow;dog=bark");
+ }
+
+ @Test
+ void inject_WithBaggage_LimitTruncates() {
+ Map carrier = new LinkedHashMap<>();
+ // Limit is 256 characters for all baggage. We add a 254-character key/value pair and a
+ // 3 character key value pair.
+ String key1 = Stream.generate(() -> "a").limit(252).collect(Collectors.joining());
+ String value1 = "a"; // 252 + 1 (=) + 1 = 254
+
+ String key2 = "b";
+ String value2 = "b"; // 1 + 1 (=) + 1 = 3
+
+ Baggage baggage = Baggage.builder().put(key1, value1).put(key2, value2).build();
+
+ xrayPropagator.inject(
+ withSpanContext(
+ SpanContext.create(
+ TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TraceState.getDefault()),
+ Context.current())
+ .with(baggage),
+ carrier,
+ setter);
+
+ assertThat(carrier)
+ .containsEntry(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=0;"
+ + key1
+ + '='
+ + value1);
+ }
+
+ @Test
+ void inject_WithTraceState() {
+ Map carrier = new LinkedHashMap<>();
+ xrayPropagator.inject(
+ withSpanContext(
+ SpanContext.create(
+ TRACE_ID,
+ SPAN_ID,
+ TraceFlags.getDefault(),
+ TraceState.builder().put("foo", "bar").build()),
+ Context.current()),
+ carrier,
+ setter);
+
+ // TODO: assert trace state when the propagator supports it, for general key/value pairs we are
+ // mapping with baggage.
+ assertThat(carrier)
+ .containsEntry(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=0");
+ }
+
+ @Test
+ void inject_nullContext() {
+ Map carrier = new LinkedHashMap<>();
+ xrayPropagator.inject(null, carrier, setter);
+ assertThat(carrier).isEmpty();
+ }
+
+ @Test
+ void inject_nullSetter() {
+ Map carrier = new LinkedHashMap<>();
+ Context context =
+ withSpanContext(
+ SpanContext.create(TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TraceState.getDefault()),
+ Context.current());
+ xrayPropagator.inject(context, carrier, null);
+ assertThat(carrier).isEmpty();
+ }
+
+ @Test
+ void extract_Nothing() {
+ // Context remains untouched.
+ assertThat(
+ xrayPropagator.extract(
+ Context.current(), Collections.emptyMap(), getter))
+ .isSameAs(Context.current());
+ }
+
+ @Test
+ void extract_SampledContext() {
+ Map carrier = new LinkedHashMap<>();
+ carrier.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=1");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
+ .isEqualTo(
+ SpanContext.createFromRemoteParent(
+ TRACE_ID, SPAN_ID, TraceFlags.getSampled(), TraceState.getDefault()));
+ }
+
+ @Test
+ void extract_NotSampledContext() {
+ Map carrier = new LinkedHashMap<>();
+ carrier.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=0");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
+ .isEqualTo(
+ SpanContext.createFromRemoteParent(
+ TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TraceState.getDefault()));
+ }
+
+ @Test
+ void extract_DifferentPartOrder() {
+ Map carrier = new LinkedHashMap<>();
+ carrier.put(
+ TRACE_HEADER_KEY,
+ "Parent=53995c3f42cd8ad8;Sampled=1;Root=1-8a3c60f7-d188f8fa79d48a391a778fa6");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
+ .isEqualTo(
+ SpanContext.createFromRemoteParent(
+ TRACE_ID, SPAN_ID, TraceFlags.getSampled(), TraceState.getDefault()));
+ }
+
+ @Test
+ void extract_AdditionalFields() {
+ Map carrier = new LinkedHashMap<>();
+ carrier.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=1;Foo=Bar");
+
+ Context context = xrayPropagator.extract(Context.current(), carrier, getter);
+ assertThat(getSpanContext(context))
+ .isEqualTo(
+ SpanContext.createFromRemoteParent(
+ TRACE_ID, SPAN_ID, TraceFlags.getSampled(), TraceState.getDefault()));
+ assertThat(Baggage.fromContext(context).getEntryValue("Foo")).isEqualTo("Bar");
+ }
+
+ @Test
+ void extract_Baggage_LimitTruncates() {
+ // Limit is 256 characters for all baggage. We add a 254-character key/value pair and a
+ // 3 character key value pair.
+ String key1 = Stream.generate(() -> "a").limit(252).collect(Collectors.joining());
+ String value1 = "a"; // 252 + 1 (=) + 1 = 254
+
+ String key2 = "b";
+ String value2 = "b"; // 1 + 1 (=) + 1 = 3
+
+ Map carrier = new LinkedHashMap<>();
+ carrier.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=1;"
+ + key1
+ + '='
+ + value1
+ + ';'
+ + key2
+ + '='
+ + value2);
+
+ Context context = xrayPropagator.extract(Context.current(), carrier, getter);
+ assertThat(getSpanContext(context))
+ .isEqualTo(
+ SpanContext.createFromRemoteParent(
+ TRACE_ID, SPAN_ID, TraceFlags.getSampled(), TraceState.getDefault()));
+ assertThat(Baggage.fromContext(context).getEntryValue(key1)).isEqualTo(value1);
+ assertThat(Baggage.fromContext(context).getEntryValue(key2)).isNull();
+ }
+
+ @Test
+ void extract_EmptyHeaderValue() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(TRACE_HEADER_KEY, "");
+
+ verifyInvalidBehavior(invalidHeaders);
+ }
+
+ @Test
+ void extract_InvalidTraceId() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY,
+ "Root=abcdefghijklmnopabcdefghijklmnop;Parent=53995c3f42cd8ad8;Sampled=0");
+
+ verifyInvalidBehavior(invalidHeaders);
+ }
+
+ @Test
+ void extract_InvalidTraceId_Size() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa600;Parent=53995c3f42cd8ad8;Sampled=0");
+
+ verifyInvalidBehavior(invalidHeaders);
+ }
+
+ @Test
+ void extract_InvalidSpanId() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=abcdefghijklmnop;Sampled=0");
+
+ verifyInvalidBehavior(invalidHeaders);
+ }
+
+ @Test
+ void extract_InvalidSpanId_Size() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad800;Sampled=0");
+
+ verifyInvalidBehavior(invalidHeaders);
+ }
+
+ @Test
+ void extract_InvalidFlags() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=");
+
+ verifyInvalidBehavior(invalidHeaders);
+ }
+
+ @Test
+ void extract_InvalidFlags_Size() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=10220");
+
+ verifyInvalidBehavior(invalidHeaders);
+ }
+
+ @Test
+ void extract_InvalidFlags_NonNumeric() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f7-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=a");
+
+ verifyInvalidBehavior(invalidHeaders);
+ }
+
+ @Test
+ void extract_Invalid_NoSpanId() {
+ Map invalidHeaders = new LinkedHashMap<>(1);
+ invalidHeaders.put(TRACE_HEADER_KEY, "Root=1-622422bf-59625fe25708d4660735d8ef");
+
+ verifyInvalidBehavior(invalidHeaders);
+ }
+
+ private void verifyInvalidBehavior(Map invalidHeaders) {
+ Context input = Context.current();
+ Context result = xrayPropagator.extract(input, invalidHeaders, getter);
+ assertThat(result).isSameAs(input);
+ assertThat(getSpanContext(result)).isSameAs(SpanContext.getInvalid());
+ }
+
+ @Test
+ void extract_nullContext() {
+ assertThat(xrayPropagator.extract(null, Collections.emptyMap(), getter))
+ .isSameAs(Context.root());
+ }
+
+ @Test
+ void extract_nullGetter() {
+ Context context =
+ withSpanContext(
+ SpanContext.create(TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TraceState.getDefault()),
+ Context.current());
+ assertThat(xrayPropagator.extract(context, Collections.emptyMap(), null)).isSameAs(context);
+ }
+
+ @Test
+ void extract_EpochPart_ZeroedSingleDigit() {
+ Map carrier = new LinkedHashMap<>();
+ carrier.put(
+ TRACE_HEADER_KEY,
+ "Root=1-0-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=1;Foo=Bar");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
+ .isEqualTo(
+ SpanContext.createFromRemoteParent(
+ "00000000d188f8fa79d48a391a778fa6",
+ SPAN_ID,
+ TraceFlags.getSampled(),
+ TraceState.getDefault()));
+ }
+
+ @Test
+ void extract_EpochPart_TwoChars() {
+ Map carrier = new LinkedHashMap<>();
+ carrier.put(
+ TRACE_HEADER_KEY,
+ "Root=1-1a-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=1;Foo=Bar");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
+ .isEqualTo(
+ SpanContext.createFromRemoteParent(
+ "0000001ad188f8fa79d48a391a778fa6",
+ SPAN_ID,
+ TraceFlags.getSampled(),
+ TraceState.getDefault()));
+ }
+
+ @Test
+ void extract_EpochPart_Zeroed() {
+ Map carrier = new LinkedHashMap<>();
+ carrier.put(
+ TRACE_HEADER_KEY,
+ "Root=1-00000000-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=1;Foo=Bar");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
+ .isEqualTo(
+ SpanContext.createFromRemoteParent(
+ "00000000d188f8fa79d48a391a778fa6",
+ SPAN_ID,
+ TraceFlags.getSampled(),
+ TraceState.getDefault()));
+ }
+
+ @Test
+ void extract_InvalidTraceId_EpochPart_TooLong() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY,
+ "Root=1-8a3c60f711-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=0");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), invalidHeaders, getter)))
+ .isSameAs(SpanContext.getInvalid());
+ }
+
+ @Test
+ void extract_InvalidTraceId_EpochPart_Empty() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY, "Root=1--d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=0");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), invalidHeaders, getter)))
+ .isSameAs(SpanContext.getInvalid());
+ }
+
+ @Test
+ void extract_InvalidTraceId_EpochPart_Missing() {
+ Map invalidHeaders = new LinkedHashMap<>();
+ invalidHeaders.put(
+ TRACE_HEADER_KEY, "Root=1-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=0");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), invalidHeaders, getter)))
+ .isSameAs(SpanContext.getInvalid());
+ }
+
+ @Test
+ void extract_InvalidTraceId_WrongVersion() {
+ Map carrier = new LinkedHashMap<>();
+ carrier.put(
+ TRACE_HEADER_KEY,
+ "Root=2-1a2a3a4a-d188f8fa79d48a391a778fa6;Parent=53995c3f42cd8ad8;Sampled=1;Foo=Bar");
+
+ assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
+ .isSameAs(SpanContext.getInvalid());
+ }
+
+ private static Context withSpanContext(SpanContext spanContext, Context context) {
+ return context.with(Span.wrap(spanContext));
+ }
+
+ private static SpanContext getSpanContext(Context context) {
+ return Span.fromContext(context).getSpanContext();
+ }
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index d029c02bb..431f7ba95 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -40,6 +40,7 @@ rootProject.name = "opentelemetry-java-contrib"
include(":all")
include(":aws-resources")
include(":aws-xray")
+include(":aws-xray-propagator")
include(":consistent-sampling")
include(":dependencyManagement")
include(":example")