diff --git a/components/context/src/main/java/datadog/context/propagation/CarrierKeys.java b/components/context/src/main/java/datadog/context/propagation/CarrierKeys.java index 112b4e34fe1..b610483f7b6 100644 --- a/components/context/src/main/java/datadog/context/propagation/CarrierKeys.java +++ b/components/context/src/main/java/datadog/context/propagation/CarrierKeys.java @@ -23,9 +23,10 @@ */ public final class CarrierKeys { private static final CarrierKeys ALL = - new CarrierKeys(true, new String[0][], new byte[0][][], new String[0]); + new CarrierKeys(true, new String[0][], new byte[0][][], new HeaderSchema[0][], new String[0]); private static final CarrierKeys NONE = - new CarrierKeys(false, new String[0][], new byte[0][][], new String[0]); + new CarrierKeys( + false, new String[0][], new byte[0][][], new HeaderSchema[0][], new String[0]); private final boolean all; @@ -35,14 +36,22 @@ public final class CarrierKeys { /** Each name's lower-case ASCII bytes (null if it isn't ASCII), parallel to the names. */ private final byte[][][] asciiByLength; + /** Each name's {@link HeaderSchema} constant, or null, parallel to {@link #namesByLength}. */ + private final HeaderSchema[][] headersByLength; + /** Lower-cased prefixes. */ private final String[] prefixes; private CarrierKeys( - boolean all, String[][] namesByLength, byte[][][] asciiByLength, String[] prefixes) { + boolean all, + String[][] namesByLength, + byte[][][] asciiByLength, + HeaderSchema[][] headersByLength, + String[] prefixes) { this.all = all; this.namesByLength = namesByLength; this.asciiByLength = asciiByLength; + this.headersByLength = headersByLength; this.prefixes = prefixes; } @@ -61,6 +70,15 @@ public static CarrierKeys of(String... names) { return builder().names(Arrays.asList(names)).build(); } + /** Exactly these headers. */ + public static CarrierKeys of(HeaderSchema... headers) { + Builder builder = builder(); + for (HeaderSchema header : headers) { + builder.header(header); + } + return builder.build(); + } + public static Builder builder() { return new Builder(); } @@ -109,13 +127,49 @@ public boolean containsAscii(ByteBuffer key) { * that matched a key's bytes use the name as the key without decoding it. Reads only. */ public String nameAscii(ByteBuffer key) { + int index = indexAscii(key); + return index < 0 ? null : namesByLength[key.remaining()][index]; + } + + /** + * The {@link HeaderSchema} constant of the declared name that the ASCII bytes between {@code + * key}'s position and limit spell, ignoring case; null if they spell no declared name, or one + * with no constant (such as a configured header tag). Reads only. + */ + public HeaderSchema headerAscii(ByteBuffer key) { + int index = indexAscii(key); + return index < 0 ? null : headersByLength[key.remaining()][index]; + } + + /** + * The {@link HeaderSchema} constant of the declared name {@code key} is, ignoring case; null if + * it's no declared name, or one with no constant. + */ + public HeaderSchema header(String key) { + int length = key.length(); + if (length < namesByLength.length) { + String[] names = namesByLength[length]; + if (names != null) { + for (int i = 0; i < names.length; i++) { + // usually lower case already: the declared name itself, or a decoded copy of it + if (names[i].equals(key) || names[i].regionMatches(true, 0, key, 0, length)) { + return headersByLength[length][i]; + } + } + } + } + return null; + } + + /** The index, among the names of its length, of the name {@code key}'s bytes spell, or -1. */ + private int indexAscii(ByteBuffer key) { int length = key.remaining(); if (length >= namesByLength.length) { - return null; + return -1; } String[] names = namesByLength[length]; if (names == null) { - return null; + return -1; } int start = key.position(); if (key.hasArray()) { @@ -126,19 +180,19 @@ public String nameAscii(ByteBuffer key) { byte[][] asciiNames = asciiByLength[length]; for (int i = 0; i < names.length; i++) { if (bytesEqual(bytes, offset, asciiNames[i], length)) { - return names[i]; + return i; } } if (!hasUpperCase(bytes, offset, length)) { - return null; + return -1; } } - for (String name : names) { - if (asciiMatches(key, start, name, length)) { - return name; + for (int i = 0; i < names.length; i++) { + if (asciiMatches(key, start, names[i], length)) { + return i; } } - return null; + return -1; } /** Whether {@code length} bytes from {@code offset} are {@code expected}'s (null: never). */ @@ -227,6 +281,12 @@ public static final class Builder { private Builder() {} + /** Adds {@code header}'s name, which then matches as that constant. */ + public Builder header(HeaderSchema header) { + names.add(header.headerName); + return this; + } + public Builder name(String name) { if (name != null && !name.isEmpty()) { names.add(name.toLowerCase(Locale.ROOT)); @@ -287,10 +347,16 @@ public CarrierKeys build() { sameLength.add(name); } String[][] namesByLength = new String[names.isEmpty() ? 0 : maxLength + 1][]; + HeaderSchema[][] headersByLength = new HeaderSchema[namesByLength.length][]; for (int i = 0; i < namesByLength.length; i++) { List sameLength = grouped.get(i); if (sameLength != null) { namesByLength[i] = sameLength.toArray(new String[0]); + headersByLength[i] = new HeaderSchema[namesByLength[i].length]; + for (int j = 0; j < namesByLength[i].length; j++) { + // any declared name that is a known header matches as its constant + headersByLength[i][j] = HeaderSchema.forName(namesByLength[i][j]); + } } } byte[][][] asciiByLength = new byte[namesByLength.length][][]; @@ -302,7 +368,8 @@ public CarrierKeys build() { } } } - return new CarrierKeys(false, namesByLength, asciiByLength, prefixes.toArray(new String[0])); + return new CarrierKeys( + false, namesByLength, asciiByLength, headersByLength, prefixes.toArray(new String[0])); } /** {@code name}'s ASCII bytes, or null if it has a char outside ASCII. */ diff --git a/components/context/src/main/java/datadog/context/propagation/CompositePropagator.java b/components/context/src/main/java/datadog/context/propagation/CompositePropagator.java index 42120f2281a..ebd11bbdc90 100644 --- a/components/context/src/main/java/datadog/context/propagation/CompositePropagator.java +++ b/components/context/src/main/java/datadog/context/propagation/CompositePropagator.java @@ -64,8 +64,9 @@ public void inject(Context context, C carrier, CarrierSetter setter) { @Override public Context extract(Context context, C carrier, CarrierVisitor visitor) { // Extract and cache the carrier key/value pairs the propagators read - CarrierCache carrierCache = new CarrierCache(); - visitor.forEachKeyValue(carrier, keys(), carrierCache); + CarrierKeys keys = keys(); + CarrierCache carrierCache = new CarrierCache(keys); + visitor.forEachKeyValue(carrier, keys, carrierCache); // Run the multiple extractions on cache for (Propagator propagator : this.propagators) { context = propagator.extract(context, carrierCache, carrierCache); @@ -85,16 +86,36 @@ static final class CarrierCache /** Keys at even indexes, values at odd ones. */ private String[] keysAndValues = new String[2 * INITIAL_PAIRS]; + /** + * Each pair's {@link HeaderSchema} constant as {@code ordinal() + 1}, or 0 for none: a byte per + * pair rather than a reference, since there are fewer than 127 constants. + */ + private byte[] headers = new byte[INITIAL_PAIRS]; + private int size; + /** Classifies keys with {@code keys}, which knows each declared name's constant. */ + private final CarrierKeys keys; + + CarrierCache(CarrierKeys keys) { + this.keys = keys; + } + + CarrierCache() { + this(CarrierKeys.none()); + } + @Override public void accept(String key, String value) { int index = 2 * this.size; if (index == this.keysAndValues.length) { this.keysAndValues = Arrays.copyOf(this.keysAndValues, 2 * index); + this.headers = Arrays.copyOf(this.headers, this.size * 2); } this.keysAndValues[index] = key; this.keysAndValues[index + 1] = value; + HeaderSchema header = key == null ? null : this.keys.header(key); + this.headers[this.size] = header == null ? 0 : (byte) (header.ordinal() + 1); this.size++; } @@ -119,5 +140,11 @@ public String key(int index) { public String value(int index) { return this.keysAndValues[2 * index + 1]; } + + @Override + public HeaderSchema header(int index) { + int header = this.headers[index]; + return header == 0 ? null : HeaderSchema.fromOrdinal(header - 1); + } } } diff --git a/components/context/src/main/java/datadog/context/propagation/HeaderSchema.java b/components/context/src/main/java/datadog/context/propagation/HeaderSchema.java new file mode 100644 index 00000000000..8e23137cacd --- /dev/null +++ b/components/context/src/main/java/datadog/context/propagation/HeaderSchema.java @@ -0,0 +1,108 @@ +package datadog.context.propagation; + +import static java.nio.charset.StandardCharsets.US_ASCII; + +/** + * The carrier keys (headers) the tracer knows by name, each with the encodings carriers commonly + * need, computed once. Propagators read a carrier's keys through {@link CarrierKeys}, which tells a + * key's constant from its characters or bytes, so code that handles several headers can switch on + * the constant instead of comparing strings. + * + *

A constant's {@link #ordinal()} is a dense index: per-header state, or carrier-specific forms + * of a header name (a Netty {@code AsciiString}, a gRPC {@code Metadata.Key}), belong in an array + * of length {@code HeaderSchema.values().length}, indexed by ordinal and filled once, which keeps + * this class free of carrier dependencies. + * + *

Names are compared ignoring ASCII case, as carriers such as HTTP do. Keys that aren't known + * ahead of time (configured header tags, baggage mappings, prefixed keys) have no constant. + */ +public enum HeaderSchema { + // Datadog + X_DATADOG_TRACE_ID("x-datadog-trace-id"), + X_DATADOG_PARENT_ID("x-datadog-parent-id"), + X_DATADOG_SAMPLING_PRIORITY("x-datadog-sampling-priority"), + X_DATADOG_ORIGIN("x-datadog-origin"), + X_DATADOG_TAGS("x-datadog-tags"), + // W3C trace context + TRACEPARENT("traceparent"), + TRACESTATE("tracestate"), + // W3C baggage + BAGGAGE("baggage"), + // B3 + X_B3_TRACE_ID("x-b3-traceid"), + X_B3_SPAN_ID("x-b3-spanid"), + X_B3_SAMPLED("x-b3-sampled"), + B3("b3"), + // Haystack + HAYSTACK_TRACE_ID("trace-id"), + HAYSTACK_SPAN_ID("span-id"), + HAYSTACK_PARENT_ID("parent-id"), + // AWS X-Ray + X_AMZN_TRACE_ID("x-amzn-trace-id"), + // Data Streams Monitoring + DD_PATHWAY_CTX_BASE64("dd-pathway-ctx-base64"), + // forwarding, user agent and client IP, read by every propagation style + FORWARDED("forwarded"), + FORWARDED_FOR("forwarded-for"), + X_FORWARDED_PROTO("x-forwarded-proto"), + X_FORWARDED_HOST("x-forwarded-host"), + X_FORWARDED_FOR("x-forwarded-for"), + X_FORWARDED_PORT("x-forwarded-port"), + USER_AGENT("user-agent"), + X_CLIENT_IP("x-client-ip"), + TRUE_CLIENT_IP("true-client-ip"), + X_CLUSTER_CLIENT_IP("x-cluster-client-ip"), + X_REAL_IP("x-real-ip"), + FASTLY_CLIENT_IP("fastly-client-ip"), + CF_CONNECTING_IP("cf-connecting-ip"), + CF_CONNECTING_IP_V6("cf-connecting-ipv6"); + + private static final HeaderSchema[] VALUES = values(); + + /** The header name, lower case. */ + public final String headerName; + + /** {@link #headerName} in ASCII, for matching or writing a key without encoding it. */ + private final byte[] asciiName; + + /** {@code headerName} must be lower case, as {@code HeaderSchemaTest} checks. */ + HeaderSchema(String headerName) { + this.headerName = headerName; + this.asciiName = headerName.getBytes(US_ASCII); + } + + /** The length of {@link #headerName}, in chars and in ASCII bytes. */ + public int length() { + return asciiName.length; + } + + /** {@link #headerName}'s ASCII byte at {@code index}. */ + public byte asciiByte(int index) { + return asciiName[index]; + } + + /** A copy of {@link #headerName} in ASCII. */ + public byte[] asciiName() { + return asciiName.clone(); + } + + /** The number of constants: the length of an array indexed by {@link #ordinal()}. */ + public static int count() { + return VALUES.length; + } + + /** The constant whose {@link #headerName} is {@code lowerCaseName}, or null. */ + public static HeaderSchema forName(String lowerCaseName) { + for (HeaderSchema header : VALUES) { + if (header.headerName.equals(lowerCaseName)) { + return header; + } + } + return null; + } + + /** The constant with {@code ordinal}. */ + public static HeaderSchema fromOrdinal(int ordinal) { + return VALUES[ordinal]; + } +} diff --git a/components/context/src/main/java/datadog/context/propagation/IndexedCarrier.java b/components/context/src/main/java/datadog/context/propagation/IndexedCarrier.java index 9e811762ba6..09efe7d2c9a 100644 --- a/components/context/src/main/java/datadog/context/propagation/IndexedCarrier.java +++ b/components/context/src/main/java/datadog/context/propagation/IndexedCarrier.java @@ -16,4 +16,11 @@ public interface IndexedCarrier { /** The value of pair {@code index}, from 0 to {@link #size()} - 1. */ String value(int index); + + /** + * The {@link HeaderSchema} constant of pair {@code index}'s key, or null if it has none (an + * unknown key, or a key the carrier didn't classify). Lets a propagator switch on the constant + * instead of comparing names; null keys must still be checked by name. + */ + HeaderSchema header(int index); } diff --git a/components/context/src/test/java/datadog/context/propagation/CarrierCacheTest.java b/components/context/src/test/java/datadog/context/propagation/CarrierCacheTest.java index fd799e9bd1e..683f2a2c25d 100644 --- a/components/context/src/test/java/datadog/context/propagation/CarrierCacheTest.java +++ b/components/context/src/test/java/datadog/context/propagation/CarrierCacheTest.java @@ -1,6 +1,8 @@ package datadog.context.propagation; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; import datadog.context.propagation.CompositePropagator.CarrierCache; import java.util.ArrayList; @@ -50,6 +52,35 @@ void visitsEveryPairInOrder() { assertEquals("key-19=value-19", seen.get(19)); } + @Test + void recordsEachKeysHeaderConstant() { + CarrierCache cache = + new CarrierCache( + CarrierKeys.builder().header(HeaderSchema.TRACEPARENT).name("x-custom").build()); + cache.accept("traceparent", "tp"); + cache.accept("x-custom", "c"); + cache.accept(null, "no key"); + assertSame(HeaderSchema.TRACEPARENT, cache.header(0)); + assertNull(cache.header(1)); + assertNull(cache.header(2)); + assertNull(cache.key(2)); + } + + @Test + void keepsHeaderConstantsPastItsInitialCapacity() { + CarrierCache cache = new CarrierCache(CarrierKeys.of(HeaderSchema.BAGGAGE)); + for (int i = 0; i < 20; i++) { + cache.accept(i % 2 == 0 ? "baggage" : "key-" + i, "value-" + i); + } + for (int i = 0; i < 20; i++) { + if (i % 2 == 0) { + assertSame(HeaderSchema.BAGGAGE, cache.header(i)); + } else { + assertNull(cache.header(i)); + } + } + } + @Test void emptyCache() { CarrierCache cache = new CarrierCache(); diff --git a/components/context/src/test/java/datadog/context/propagation/CarrierKeysTest.java b/components/context/src/test/java/datadog/context/propagation/CarrierKeysTest.java index 1dc9fcf29eb..01433f821c2 100644 --- a/components/context/src/test/java/datadog/context/propagation/CarrierKeysTest.java +++ b/components/context/src/test/java/datadog/context/propagation/CarrierKeysTest.java @@ -80,6 +80,41 @@ void nameAsciiReturnsTheDeclaredName() { assertEquals(3, buffer.position(), "position moved"); } + @Test + void knownHeadersMatchAsTheirConstant() { + CarrierKeys keys = + CarrierKeys.builder() + .header(HeaderSchema.X_DATADOG_PARENT_ID) + .name("TraceParent") + .name("x-custom-header") + .prefix("ot-baggage-") + .build(); + // declared as a constant, or by a name that is a known header, either way + assertSame(HeaderSchema.X_DATADOG_PARENT_ID, keys.header("X-Datadog-Parent-Id")); + assertSame(HeaderSchema.X_DATADOG_PARENT_ID, keys.headerAscii(bytes("x-datadog-parent-id"))); + assertSame(HeaderSchema.TRACEPARENT, keys.header("traceparent")); + assertSame(HeaderSchema.TRACEPARENT, keys.headerAscii(bytes("TRACEPARENT"))); + // a declared name with no constant, a prefix match, or an undeclared known header: no constant + assertNull(keys.header("x-custom-header")); + assertNull(keys.headerAscii(bytes("x-custom-header"))); + assertTrue(keys.contains("x-custom-header")); + assertNull(keys.header("ot-baggage-user")); + assertNull(keys.header("tracestate")); + assertNull(keys.headerAscii(bytes("tracestate"))); + assertSame(HeaderSchema.BAGGAGE, CarrierKeys.of(HeaderSchema.BAGGAGE).header("baggage")); + assertNull(CarrierKeys.all().header("baggage")); + assertNull(CarrierKeys.none().headerAscii(bytes("baggage"))); + } + + @Test + void unionKeepsConstants() { + CarrierKeys union = + CarrierKeys.of(HeaderSchema.TRACEPARENT).union(CarrierKeys.of("x-custom-header")); + assertSame(HeaderSchema.TRACEPARENT, union.header("traceparent")); + assertNull(union.header("x-custom-header")); + assertTrue(union.contains("x-custom-header")); + } + @Test void nonAsciiBytesMatchNothing() { assertFalse(KEYS.containsAscii(bytes("traceparént"))); diff --git a/components/context/src/test/java/datadog/context/propagation/HeaderSchemaTest.java b/components/context/src/test/java/datadog/context/propagation/HeaderSchemaTest.java new file mode 100644 index 00000000000..957c537670d --- /dev/null +++ b/components/context/src/test/java/datadog/context/propagation/HeaderSchemaTest.java @@ -0,0 +1,61 @@ +package datadog.context.propagation; + +import static java.nio.charset.StandardCharsets.US_ASCII; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.HashSet; +import java.util.Locale; +import java.util.Set; +import org.junit.jupiter.api.Test; + +class HeaderSchemaTest { + + @Test + void namesAreUniqueAndLowerCase() { + Set names = new HashSet<>(); + for (HeaderSchema header : HeaderSchema.values()) { + assertEquals(header.headerName.toLowerCase(Locale.ROOT), header.headerName); + assertTrue(names.add(header.headerName), "duplicate " + header.headerName); + } + } + + @Test + void encodingsMatchTheName() { + for (HeaderSchema header : HeaderSchema.values()) { + byte[] ascii = header.headerName.getBytes(US_ASCII); + assertArrayEquals(ascii, header.asciiName()); + assertEquals(ascii.length, header.length()); + for (int i = 0; i < ascii.length; i++) { + assertEquals(ascii[i], header.asciiByte(i)); + } + } + } + + @Test + void asciiNameIsACopy() { + byte[] copy = HeaderSchema.TRACEPARENT.asciiName(); + copy[0] = 'X'; + assertEquals('t', HeaderSchema.TRACEPARENT.asciiByte(0)); + } + + @Test + void ordinalsFitInAByte() { + // CarrierCache stores ordinal() + 1 in a byte + assertTrue(HeaderSchema.count() < Byte.MAX_VALUE); + } + + @Test + void lookupsByNameAndOrdinal() { + assertEquals(HeaderSchema.values().length, HeaderSchema.count()); + for (HeaderSchema header : HeaderSchema.values()) { + assertSame(header, HeaderSchema.forName(header.headerName)); + assertSame(header, HeaderSchema.fromOrdinal(header.ordinal())); + } + assertNull(HeaderSchema.forName("x-custom-header")); + assertNull(HeaderSchema.forName("Traceparent")); + } +} diff --git a/dd-trace-core/src/main/java/datadog/trace/core/baggage/BaggagePropagator.java b/dd-trace-core/src/main/java/datadog/trace/core/baggage/BaggagePropagator.java index 6788f55c360..fa504966bc4 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/baggage/BaggagePropagator.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/baggage/BaggagePropagator.java @@ -4,6 +4,8 @@ import datadog.context.propagation.CarrierKeys; import datadog.context.propagation.CarrierSetter; import datadog.context.propagation.CarrierVisitor; +import datadog.context.propagation.HeaderSchema; +import datadog.context.propagation.IndexedCarrier; import datadog.context.propagation.Propagator; import datadog.trace.api.Config; import datadog.trace.api.metrics.BaggageMetrics; @@ -125,7 +127,18 @@ public Context extract(Context context, C carrier, CarrierVisitor visitor return context; } BaggageExtractor baggageExtractor = new BaggageExtractor(); - visitor.forEachKeyValue(carrier, baggageExtractor); + if (carrier instanceof IndexedCarrier) { + // only the baggage header, or a key without a header constant, can be baggage + IndexedCarrier indexed = (IndexedCarrier) carrier; + for (int i = 0, n = indexed.size(); i < n; i++) { + HeaderSchema header = indexed.header(i); + if (header == null || header == HeaderSchema.BAGGAGE) { + baggageExtractor.accept(indexed.key(i), indexed.value(i)); + } + } + } else { + visitor.forEachKeyValue(carrier, baggageExtractor); + } Baggage baggage = baggageExtractor.extracted; if (baggage == null) { return context; diff --git a/dd-trace-core/src/main/java/datadog/trace/core/propagation/B3HttpCodec.java b/dd-trace-core/src/main/java/datadog/trace/core/propagation/B3HttpCodec.java index 14818b27537..b3fee7348cb 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/propagation/B3HttpCodec.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/propagation/B3HttpCodec.java @@ -182,6 +182,9 @@ public static HttpCodec.Extractor newSingleExtractor( } private abstract static class B3BaseContextInterpreter extends ContextInterpreter { + // Not opted into header-constant dispatch (classify stays BY_NAME): accept wraps the shared + // forwarding / user agent handling and the common tail in its try/catch, which the generic + // dispatch would move outside it. /** * This style's own headers; the ones every style reads come from {@link ContextInterpreter}. */ diff --git a/dd-trace-core/src/main/java/datadog/trace/core/propagation/ContextInterpreter.java b/dd-trace-core/src/main/java/datadog/trace/core/propagation/ContextInterpreter.java index 540f3d7a08a..9094706e1d1 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/propagation/ContextInterpreter.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/propagation/ContextInterpreter.java @@ -16,6 +16,7 @@ import static datadog.trace.core.propagation.HttpCodec.X_REAL_IP_KEY; import datadog.context.propagation.CarrierKeys; +import datadog.context.propagation.HeaderSchema; import datadog.trace.api.Config; import datadog.trace.api.DDSpanId; import datadog.trace.api.DDTraceId; @@ -161,6 +162,81 @@ final CarrierKeys keys(TraceConfig traceConfig) { .build(); } + /** {@link #classify}: a known header this style doesn't read itself. */ + protected static final int NOT_OWN_HEADER = -1; + + /** {@link #classify}: handle the header by name, as {@link #accept(String, String)} does. */ + protected static final int BY_NAME = -2; + + /** + * {@link #accept(String, String)} for a key whose {@link HeaderSchema} constant the carrier + * already knows: the style's own headers go straight to {@link #acceptClassified}, the shared + * forwarding and user agent headers to their handlers, and other known headers to {@link + * #acceptUnclassified}, without comparing names. A null constant, or a style that doesn't {@link + * #classify} the header, takes the by-name path, so the result is the same either way. + */ + @Override + public boolean accept(HeaderSchema header, String key, String value) { + if (header == null || LOG_EXTRACT_HEADER_NAMES || key == null || key.isEmpty()) { + return accept(key, value); + } + int classification = classify(header); + if (classification == BY_NAME) { + return accept(key, value); + } + if (classification != NOT_OWN_HEADER) { + return acceptClassified(classification, key, value); + } + switch (header) { + case FORWARDED: + case FORWARDED_FOR: + handledForwarding(key, value); + break; + case USER_AGENT: + handledUserAgent(key, value); + break; + case X_FORWARDED_PROTO: + case X_FORWARDED_HOST: + case X_FORWARDED_FOR: + case X_FORWARDED_PORT: + handledXForwarding(key, value); + break; + default: + } + return acceptUnclassified(key, value); + } + + /** + * How this style handles {@code header}: one of its own classifications (non-negative, for {@link + * #acceptClassified}), {@link #NOT_OWN_HEADER} for a header it doesn't read itself, or {@link + * #BY_NAME}, the default, to handle it exactly as {@link #accept(String, String)} does. + */ + protected int classify(HeaderSchema header) { + return BY_NAME; + } + + /** + * Handles a value of one of this style's own headers, classified by {@link #classify}, as {@link + * #accept(String, String)} would. Only called for classifications {@link #classify} returns. + */ + protected boolean acceptClassified(int classification, String key, String value) { + return accept(key, value); + } + + /** + * Handles a key that isn't one of this style's own headers, after the forwarding and user agent + * handlers: client IP headers, request header tags and mapped baggage, as {@link #accept(String, + * String)} does for such keys. + */ + protected boolean acceptUnclassified(String key, String value) { + handledIpHeaders(key, value); + if (handleTags(key, value)) { + return true; + } + handleMappedBaggage(key, value); + return true; + } + protected final boolean handledForwarding(String key, String value) { if (value == null || !collectIpHeaders) { return false; diff --git a/dd-trace-core/src/main/java/datadog/trace/core/propagation/DatadogHttpCodec.java b/dd-trace-core/src/main/java/datadog/trace/core/propagation/DatadogHttpCodec.java index 7fc533ec5bf..38dc2b0298b 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/propagation/DatadogHttpCodec.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/propagation/DatadogHttpCodec.java @@ -10,6 +10,7 @@ import datadog.context.propagation.CarrierKeys; import datadog.context.propagation.CarrierSetter; +import datadog.context.propagation.HeaderSchema; import datadog.trace.api.Config; import datadog.trace.api.DD128bTraceId; import datadog.trace.api.DDSpanId; @@ -197,48 +198,74 @@ public boolean accept(String key, String value) { } if (classification != IGNORE) { - try { - if (null != value) { - switch (classification) { - case TRACE_ID: - traceId = DDTraceId.from(firstHeaderValue(value)); - break; - case SPAN_ID: - spanId = DDSpanId.from(firstHeaderValue(value)); - break; - case ORIGIN: - origin = firstHeaderValue(value); - break; - case SAMPLING_PRIORITY: - samplingPriority = Integer.parseInt(firstHeaderValue(value)); - break; - case E2E_START: - endToEndStartTime = extractEndToEndStartTime(firstHeaderValue(value)); - break; - case DD_TAGS: - datadogTags = value; - break; - case OT_BAGGAGE: - addBaggageItem(lowerCaseKey.substring(OT_BAGGAGE_PREFIX.length()), value); - break; - default: - } + return handleClassified(classification, key, value, lowerCaseKey); + } + return acceptUnclassified(key, value); + } + + @Override + protected int classify(HeaderSchema header) { + switch (header) { + case X_DATADOG_TRACE_ID: + return TRACE_ID; + case X_DATADOG_PARENT_ID: + return SPAN_ID; + case X_DATADOG_SAMPLING_PRIORITY: + return SAMPLING_PRIORITY; + case X_DATADOG_ORIGIN: + return ORIGIN; + case X_DATADOG_TAGS: + return DD_TAGS; + case X_AMZN_TRACE_ID: + return BY_NAME; // read only when AWS propagation is enabled + default: + return NOT_OWN_HEADER; + } + } + + @Override + protected boolean acceptClassified(int classification, String key, String value) { + return handleClassified(classification, key, value, null); + } + + /** Stores the value of a key classified as one of this style's own. */ + private boolean handleClassified( + int classification, String key, String value, String lowerCaseKey) { + try { + if (null != value) { + switch (classification) { + case TRACE_ID: + traceId = DDTraceId.from(firstHeaderValue(value)); + break; + case SPAN_ID: + spanId = DDSpanId.from(firstHeaderValue(value)); + break; + case ORIGIN: + origin = firstHeaderValue(value); + break; + case SAMPLING_PRIORITY: + samplingPriority = Integer.parseInt(firstHeaderValue(value)); + break; + case E2E_START: + endToEndStartTime = extractEndToEndStartTime(firstHeaderValue(value)); + break; + case DD_TAGS: + datadogTags = value; + break; + case OT_BAGGAGE: + addBaggageItem(lowerCaseKey.substring(OT_BAGGAGE_PREFIX.length()), value); + break; + default: } - } catch (NumberFormatException e) { - invalidateContext(); - log.debug(EXCLUDE_TELEMETRY, "Ignoring context with invalid {}: {}", key, value); - return false; - } catch (RuntimeException e) { - invalidateContext(); - log.debug("Exception when extracting context", e); - return false; } - } else { - handledIpHeaders(key, value); - if (handleTags(key, value)) { - return true; - } - handleMappedBaggage(key, value); + } catch (NumberFormatException e) { + invalidateContext(); + log.debug(EXCLUDE_TELEMETRY, "Ignoring context with invalid {}: {}", key, value); + return false; + } catch (RuntimeException e) { + invalidateContext(); + log.debug("Exception when extracting context", e); + return false; } return true; } diff --git a/dd-trace-core/src/main/java/datadog/trace/core/propagation/HaystackHttpCodec.java b/dd-trace-core/src/main/java/datadog/trace/core/propagation/HaystackHttpCodec.java index 5103bfcfff2..95f218c4d0a 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/propagation/HaystackHttpCodec.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/propagation/HaystackHttpCodec.java @@ -5,6 +5,7 @@ import datadog.context.propagation.CarrierKeys; import datadog.context.propagation.CarrierSetter; +import datadog.context.propagation.HeaderSchema; import datadog.trace.api.Config; import datadog.trace.api.DD64bTraceId; import datadog.trace.api.DDSpanId; @@ -212,40 +213,59 @@ public boolean accept(String key, String value) { } if (IGNORE != classification) { - try { - String firstValue = firstHeaderValue(value); - if (null != firstValue) { - switch (classification) { - case TRACE_ID: - traceId = DD64bTraceId.fromHex(convertUUIDToHexString(firstValue)); - addReservedBaggageItem(HAYSTACK_TRACE_ID_BAGGAGE_KEY, firstValue); - break; - case SPAN_ID: - spanId = DDSpanId.fromHex(convertUUIDToHexString(firstValue)); - addReservedBaggageItem(HAYSTACK_SPAN_ID_BAGGAGE_KEY, firstValue); - break; - case PARENT_ID: - addBaggageItem(HAYSTACK_PARENT_ID_BAGGAGE_KEY, firstValue); + return handleClassified(classification, value, lowerCaseKey); + } + return acceptUnclassified(key, value); + } + + @Override + protected int classify(HeaderSchema header) { + switch (header) { + case HAYSTACK_TRACE_ID: + return TRACE_ID; + case HAYSTACK_SPAN_ID: + return SPAN_ID; + case HAYSTACK_PARENT_ID: + return PARENT_ID; + default: + return NOT_OWN_HEADER; + } + } + + @Override + protected boolean acceptClassified(int classification, String key, String value) { + return handleClassified(classification, value, null); + } + + /** Stores the value of a key classified as one of this style's own. */ + private boolean handleClassified(int classification, String value, String lowerCaseKey) { + try { + String firstValue = firstHeaderValue(value); + if (null != firstValue) { + switch (classification) { + case TRACE_ID: + traceId = DD64bTraceId.fromHex(convertUUIDToHexString(firstValue)); + addReservedBaggageItem(HAYSTACK_TRACE_ID_BAGGAGE_KEY, firstValue); + break; + case SPAN_ID: + spanId = DDSpanId.fromHex(convertUUIDToHexString(firstValue)); + addReservedBaggageItem(HAYSTACK_SPAN_ID_BAGGAGE_KEY, firstValue); + break; + case PARENT_ID: + addBaggageItem(HAYSTACK_PARENT_ID_BAGGAGE_KEY, firstValue); + break; + case BAGGAGE: + { + addBaggageItem(lowerCaseKey.substring(BAGGAGE_PREFIX_LC.length()), value); break; - case BAGGAGE: - { - addBaggageItem(lowerCaseKey.substring(BAGGAGE_PREFIX_LC.length()), value); - break; - } - default: - } + } + default: } - } catch (RuntimeException e) { - invalidateContext(); - log.debug("Exception when extracting context", e); - return false; - } - } else { - handledIpHeaders(key, value); - if (handleTags(key, value)) { - return true; } - handleMappedBaggage(key, value); + } catch (RuntimeException e) { + invalidateContext(); + log.debug("Exception when extracting context", e); + return false; } return true; } diff --git a/dd-trace-core/src/main/java/datadog/trace/core/propagation/HttpCodec.java b/dd-trace-core/src/main/java/datadog/trace/core/propagation/HttpCodec.java index 30da4e8b2a9..72e689b75c8 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/propagation/HttpCodec.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/propagation/HttpCodec.java @@ -6,6 +6,7 @@ import datadog.context.propagation.CarrierKeys; import datadog.context.propagation.CarrierSetter; +import datadog.context.propagation.HeaderSchema; import datadog.context.propagation.IndexedCarrier; import datadog.trace.api.Config; import datadog.trace.api.DD128bTraceId; @@ -393,7 +394,12 @@ public ExtractionCache(C carrier, AgentPropagation.ContextVisitor getter) { this.indexed = (IndexedCarrier) carrier; this.keysAndValues = null; for (int i = 0, n = this.indexed.size(); i < n; i++) { - cacheDatadogSpanId(this.indexed.key(i), this.indexed.value(i)); + HeaderSchema header = this.indexed.header(i); + // a known header is matched by its constant; a key without one, by name + if (header == HeaderSchema.X_DATADOG_PARENT_ID + || header == null && SPAN_ID_KEY.equalsIgnoreCase(this.indexed.key(i))) { + cacheDatadogSpanIdValue(this.indexed.value(i)); + } } } else { this.indexed = null; @@ -412,11 +418,15 @@ public boolean accept(String key, String value) { private void cacheDatadogSpanId(String key, String value) { if (SPAN_ID_KEY.equalsIgnoreCase(key)) { - try { - // Parse numeric header value to format it as 16 hexadecimal character format - this.datadogSpanIdHex = DDSpanId.toHexStringPadded(DDSpanId.from(value)); - } catch (NumberFormatException ignored) { - } + cacheDatadogSpanIdValue(value); + } + } + + private void cacheDatadogSpanIdValue(String value) { + try { + // Parse numeric header value to format it as 16 hexadecimal character format + this.datadogSpanIdHex = DDSpanId.toHexStringPadded(DDSpanId.from(value)); + } catch (NumberFormatException ignored) { } } @@ -429,7 +439,7 @@ public void forEachKey(ExtractionCache carrier, AgentPropagation.KeyClassifie IndexedCarrier indexed = carrier.indexed; if (indexed != null) { for (int i = 0, n = indexed.size(); i < n; i++) { - classifier.accept(indexed.key(i), indexed.value(i)); + classifier.accept(indexed.header(i), indexed.key(i), indexed.value(i)); } return; } diff --git a/dd-trace-core/src/main/java/datadog/trace/core/propagation/NoneCodec.java b/dd-trace-core/src/main/java/datadog/trace/core/propagation/NoneCodec.java index b1256ca2e51..f146c9b8997 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/propagation/NoneCodec.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/propagation/NoneCodec.java @@ -2,6 +2,7 @@ import datadog.context.propagation.CarrierKeys; import datadog.context.propagation.CarrierSetter; +import datadog.context.propagation.HeaderSchema; import datadog.trace.api.Config; import datadog.trace.api.TraceConfig; import datadog.trace.api.TracePropagationStyle; @@ -28,6 +29,12 @@ private NoneContextInterpreter(Config config) { super(config); } + /** No headers of its own: every known header gets the shared handling. */ + @Override + protected int classify(HeaderSchema header) { + return NOT_OWN_HEADER; + } + @Override public TracePropagationStyle style() { return TracePropagationStyle.NONE; diff --git a/dd-trace-core/src/main/java/datadog/trace/core/propagation/TracingPropagator.java b/dd-trace-core/src/main/java/datadog/trace/core/propagation/TracingPropagator.java index 6b84bd24b12..465a0c2a164 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/propagation/TracingPropagator.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/propagation/TracingPropagator.java @@ -8,6 +8,7 @@ import datadog.context.propagation.CarrierKeys; import datadog.context.propagation.CarrierSetter; import datadog.context.propagation.CarrierVisitor; +import datadog.context.propagation.IndexedCarrier; import datadog.context.propagation.Propagator; import datadog.trace.bootstrap.instrumentation.api.AgentPropagation; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; @@ -86,6 +87,16 @@ private static AgentPropagation.ContextVisitor toContextVisitor( if (visitor instanceof AgentPropagation.ContextVisitor) { return (AgentPropagation.ContextVisitor) visitor; } - return (carrier, classifier) -> visitor.forEachKeyValue(carrier, classifier::accept); + return (carrier, classifier) -> { + if (carrier instanceof IndexedCarrier) { + // the composite propagator's cache: hand each key's header constant along + IndexedCarrier indexed = (IndexedCarrier) carrier; + for (int i = 0, n = indexed.size(); i < n; i++) { + classifier.accept(indexed.header(i), indexed.key(i), indexed.value(i)); + } + } else { + visitor.forEachKeyValue(carrier, classifier::accept); + } + }; } } diff --git a/dd-trace-core/src/main/java/datadog/trace/core/propagation/W3CHttpCodec.java b/dd-trace-core/src/main/java/datadog/trace/core/propagation/W3CHttpCodec.java index bee8ec9c2b0..124095c97cb 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/propagation/W3CHttpCodec.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/propagation/W3CHttpCodec.java @@ -10,6 +10,7 @@ import datadog.context.propagation.CarrierKeys; import datadog.context.propagation.CarrierSetter; +import datadog.context.propagation.HeaderSchema; import datadog.trace.api.Config; import datadog.trace.api.DD128bTraceId; import datadog.trace.api.DDSpanId; @@ -254,33 +255,50 @@ public boolean accept(String key, String value) { } if (classification != IGNORE) { - try { - if (null != value) { - switch (classification) { - case TRACE_PARENT: - return storeTraceParent(value); - case TRACE_STATE: - return storeTraceState(value); - case E2E_START: - endToEndStartTime = extractEndToEndStartTime(firstHeaderValue(value)); - break; - case OT_BAGGAGE: - addBaggageItem(lowerCaseKey.substring(OT_BAGGAGE_PREFIX.length()), value); - break; - default: - } + return handleClassified(classification, value, lowerCaseKey); + } + return acceptUnclassified(key, value); + } + + @Override + protected int classify(HeaderSchema header) { + switch (header) { + case TRACEPARENT: + return TRACE_PARENT; + case TRACESTATE: + return TRACE_STATE; + default: + return NOT_OWN_HEADER; + } + } + + @Override + protected boolean acceptClassified(int classification, String key, String value) { + return handleClassified(classification, value, null); + } + + /** Stores the value of a key classified as one of this style's own. */ + private boolean handleClassified(int classification, String value, String lowerCaseKey) { + try { + if (null != value) { + switch (classification) { + case TRACE_PARENT: + return storeTraceParent(value); + case TRACE_STATE: + return storeTraceState(value); + case E2E_START: + endToEndStartTime = extractEndToEndStartTime(firstHeaderValue(value)); + break; + case OT_BAGGAGE: + addBaggageItem(lowerCaseKey.substring(OT_BAGGAGE_PREFIX.length()), value); + break; + default: } - } catch (RuntimeException e) { - invalidateContext(); - log.debug("Exception when extracting context", e); - return false; - } - } else { - handledIpHeaders(key, value); - if (handleTags(key, value)) { - return true; } - handleMappedBaggage(key, value); + } catch (RuntimeException e) { + invalidateContext(); + log.debug("Exception when extracting context", e); + return false; } return true; } diff --git a/dd-trace-core/src/main/java/datadog/trace/core/propagation/XRayHttpCodec.java b/dd-trace-core/src/main/java/datadog/trace/core/propagation/XRayHttpCodec.java index 327712c86c3..7d8e9772076 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/propagation/XRayHttpCodec.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/propagation/XRayHttpCodec.java @@ -134,6 +134,9 @@ public static HttpCodec.Extractor newExtractor( } static class XRayContextInterpreter extends ContextInterpreter { + // Not opted into header-constant dispatch (classify stays BY_NAME): accept wraps the shared + // forwarding / user agent handling and the common tail in its try/catch, which the generic + // dispatch would move outside it. /** * This style's own headers; the ones every style reads come from {@link ContextInterpreter}. */ diff --git a/dd-trace-core/src/test/java/datadog/trace/core/propagation/ExtractorKeysForkedTest.java b/dd-trace-core/src/test/java/datadog/trace/core/propagation/ExtractorKeysForkedTest.java index 73456b3a976..18683a94df1 100644 --- a/dd-trace-core/src/test/java/datadog/trace/core/propagation/ExtractorKeysForkedTest.java +++ b/dd-trace-core/src/test/java/datadog/trace/core/propagation/ExtractorKeysForkedTest.java @@ -10,8 +10,11 @@ import static org.junit.jupiter.api.Assumptions.assumeFalse; import datadog.context.propagation.CarrierKeys; +import datadog.context.propagation.HeaderSchema; +import datadog.context.propagation.IndexedCarrier; import datadog.trace.api.Config; import datadog.trace.api.DynamicConfig; +import datadog.trace.bootstrap.instrumentation.api.AgentPropagation; import datadog.trace.bootstrap.instrumentation.api.TagContext; import datadog.trace.core.propagation.ConsumedHeaderTagMappingTest.Style; import datadog.trace.test.util.DDJavaSpecification; @@ -215,4 +218,98 @@ void compoundExtractorKeysAreTheUnion() { assertTrue(keys.contains("traceparent")); assertSame(keys, compound.keys()); } + + /** A carrier that knows each key's header constant, as the composite propagator's cache does. */ + static final class Indexed implements IndexedCarrier { + final List keys = new ArrayList<>(); + final List values = new ArrayList<>(); + final List headers = new ArrayList<>(); + + Indexed(Map carrier, CarrierKeys classifier) { + carrier.forEach((key, value) -> { + keys.add(key); + values.add(value); + headers.add(classifier.header(key)); + }); + } + + @Override + public int size() { + return keys.size(); + } + + @Override + public String key(int index) { + return keys.get(index); + } + + @Override + public String value(int index) { + return values.get(index); + } + + @Override + public HeaderSchema header(int index) { + return headers.get(index); + } + } + + /** Visits an {@link Indexed} carrier, handing each key's constant to the classifier. */ + static final AgentPropagation.ContextVisitor WITH_HEADERS = + (carrier, classifier) -> { + for (int i = 0; i < carrier.size(); i++) { + if (!classifier.accept(carrier.header(i), carrier.key(i), carrier.value(i))) { + return; + } + } + }; + + /** Every known header, so the constant path also sees headers a style doesn't read. */ + private static CarrierKeys everyKnownHeader() { + CarrierKeys.Builder builder = CarrierKeys.builder(); + for (HeaderSchema header : HeaderSchema.values()) { + builder.header(header); + } + return builder.build(); + } + + @ParameterizedTest(name = "{0}") + @MethodSource("styles") + void dispatchingOnHeaderConstantsExtractsTheSameContext(Style style) { + HttpCodec.Extractor extractor = extractor(style); + Map headers = headers(style); + // the style's own keys, and every known header + for (CarrierKeys classifier : new CarrierKeys[] {extractor.keys(), everyKnownHeader()}) { + assertEquals( + describe(extractor.extract(headers, stringValuesMap())), + describe(extractor.extract(new Indexed(headers, classifier), WITH_HEADERS)), + classifier.toString()); + } + } + + @Test + void compoundExtractionReadsHeaderConstantsInPlace() { + DynamicConfig dynamicConfig = + DynamicConfig.create() + .setHeaderTags(Collections.singletonMap("x-custom-header", "tag.custom")) + .apply(); + List parts = new ArrayList<>(); + parts.add(DatadogHttpCodec.newExtractor(Config.get(), dynamicConfig::captureTraceConfig)); + parts.add(W3CHttpCodec.newExtractor(Config.get(), dynamicConfig::captureTraceConfig)); + HttpCodec.CompoundExtractor compound = new HttpCodec.CompoundExtractor(parts, false); + + Map headers = new LinkedHashMap<>(); + headers.put("x-datadog-trace-id", "123"); + headers.put("x-datadog-parent-id", "456"); + headers.put("x-datadog-sampling-priority", "1"); + headers.put("x-datadog-tags", "_dd.p.dm=-4"); + headers.put("traceparent", "00-0000000000000000000000000000007b-00000000000001c9-01"); + headers.put("tracestate", "dd=s:1;p:00000000000001c9"); + headers.put("X-Custom-Header", "custom"); + headers.put("content-type", "application/json"); + + assertEquals( + describe(compound.extract(headers, stringValuesMap())), + describe(compound.extract(new Indexed(headers, compound.keys()), WITH_HEADERS))); + } } diff --git a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentPropagation.java b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentPropagation.java index 46a01b3f70f..0ee46dc6164 100644 --- a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentPropagation.java +++ b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentPropagation.java @@ -8,6 +8,7 @@ import datadog.context.Context; import datadog.context.propagation.CarrierVisitor; import datadog.context.propagation.Concern; +import datadog.context.propagation.HeaderSchema; import datadog.context.propagation.Propagators; import java.util.function.BiConsumer; import java.util.function.Function; @@ -57,6 +58,17 @@ public interface KeyClassifier { default boolean accept(String key, T value, Function transformer) { return accept(key, transformer.apply(value)); } + + /** + * Variant of {@link #accept(String, String)} for carriers that already know the key's {@link + * HeaderSchema} constant (null when it has none), so a classifier handling several headers can + * switch on it instead of comparing names. The default ignores it. + * + * @return {@code false} to stop iteration, {@code true} to continue + */ + default boolean accept(HeaderSchema header, String key, String value) { + return accept(key, value); + } } public interface ContextVisitor extends CarrierVisitor {