Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -79,12 +79,19 @@ public <C> Context extract(Context context, C carrier, CarrierVisitor<C> visitor
* walking the carrier again, and readable in place as an {@link IndexedCarrier}.
*/
static final class CarrierCache
implements BiConsumer<String, String>, CarrierVisitor<CarrierCache>, IndexedCarrier {
implements BiConsumer<String, String>,
TransientValueConsumer,
CarrierVisitor<CarrierCache>,
IndexedCarrier {
/** Enough for the trace headers a carrier usually holds once unread keys are skipped. */
private static final int INITIAL_PAIRS = 8;

/** Keys at even indexes, values at odd ones. */
private String[] keysAndValues = new String[2 * INITIAL_PAIRS];
/**
* Keys at even indexes, values at odd ones. A value is a {@code String}, or a transient view
* (handed through {@link #acceptTransient}) until something reads it as a {@code String}; one
* array either way, so views cost no extra allocation.
*/
private Object[] keysAndValues = new Object[2 * INITIAL_PAIRS];

/**
* Each pair's {@link HeaderSchema} constant as {@code ordinal() + 1}, or 0 for none: a byte per
Expand All @@ -107,22 +114,32 @@ static final class CarrierCache

@Override
public void accept(String key, String value) {
add(key, value, key == null ? null : this.keys.header(key));
}

/** Keeps {@code value} as a view until something reads it as a {@code String}. */
@Override
public void acceptTransient(HeaderSchema header, String key, CharSequence value) {
// the cache lives for one extraction, so the view stays in its scope
add(key, value, header);
}

private void add(String key, CharSequence value, HeaderSchema header) {
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++;
}

@Override
public void forEachKeyValue(CarrierCache carrier, BiConsumer<String, String> visitor) {
for (int i = 0; i < carrier.size; i++) {
visitor.accept(carrier.keysAndValues[2 * i], carrier.keysAndValues[2 * i + 1]);
visitor.accept(carrier.key(i), carrier.value(i));
}
}

Expand All @@ -133,12 +150,24 @@ public int size() {

@Override
public String key(int index) {
return this.keysAndValues[2 * index];
return (String) this.keysAndValues[2 * index];
}

/** The value as a {@code String}, copying a view once (and keeping the copy). */
@Override
public String value(int index) {
return this.keysAndValues[2 * index + 1];
Object value = this.keysAndValues[2 * index + 1];
if (value == null || value instanceof String) {
return (String) value;
}
String copy = value.toString();
this.keysAndValues[2 * index + 1] = copy;
return copy;
}

@Override
public CharSequence valueView(int index) {
return (CharSequence) this.keysAndValues[2 * index + 1];
}

@Override
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -18,9 +18,9 @@
*/
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_TRACE_ID("x-datadog-trace-id", true),
X_DATADOG_PARENT_ID("x-datadog-parent-id", true),
X_DATADOG_SAMPLING_PRIORITY("x-datadog-sampling-priority", true),
X_DATADOG_ORIGIN("x-datadog-origin"),
X_DATADOG_TAGS("x-datadog-tags"),
// W3C trace context
Expand Down Expand Up @@ -65,12 +65,30 @@ public enum HeaderSchema {
/** {@link #headerName} in ASCII, for matching or writing a key without encoding it. */
private final byte[] asciiName;

/** Whether the header's value is only parsed: see {@link #isParseOnly()}. */
private final boolean parseOnly;

/** {@code headerName} must be lower case, as {@code HeaderSchemaTest} checks. */
HeaderSchema(String headerName) {
this(headerName, false);
}

HeaderSchema(String headerName, boolean parseOnly) {
this.headerName = headerName;
this.parseOnly = parseOnly;
this.asciiName = headerName.getBytes(US_ASCII);
}

/**
* Whether every propagator that reads this header only parses its value (into a number, say) and
* keeps nothing of it, so a carrier may hand the value as a transient view instead of decoding it
* (see {@link TransientValueConsumer}). A propagator that starts keeping such a value must copy
* it, or this must change.
*/
public boolean isParseOnly() {
return parseOnly;
}

/** The length of {@link #headerName}, in chars and in ASCII bytes. */
public int length() {
return asciiName.length;
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -14,9 +14,18 @@ public interface IndexedCarrier {
/** The key of pair {@code index}, from 0 to {@link #size()} - 1. */
String key(int index);

/** The value of pair {@code index}, from 0 to {@link #size()} - 1. */
/** The value of pair {@code index}, from 0 to {@link #size()} - 1, as a {@code String}. */
String value(int index);

/**
* The value of pair {@code index}, possibly a transient view (see {@link TransientValueConsumer})
* valid only during the extraction: parse it, or copy it to keep it. The default returns {@link
* #value(int)}.
*/
default CharSequence valueView(int index) {
return value(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
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,22 @@
package datadog.context.propagation;

/**
* A carrier visitor's callback that can take a value as a transient view: a {@code CharSequence}
* valid only during the call, for a carrier that holds values as bytes and can avoid decoding them.
* A carrier may hand a value this way only for a key whose {@link HeaderSchema} constant {@link
* HeaderSchema#isParseOnly() is parse-only}, and only if the visitor implements this interface;
* otherwise it decodes the value and calls {@code accept(key, value)} as usual.
*
* <p>An implementation must not keep the view past the call, nor hand it to anything that might: it
* may share the carrier's whole buffer. It copies the value ({@code toString()}) to keep it.
*/
public interface TransientValueConsumer {
/**
* Takes {@code key}'s value as a view valid only during this call.
*
* @param header {@code key}'s constant, which is parse-only
* @param key the key
* @param value the value, valid only during this call
*/
void acceptTransient(HeaderSchema header, String key, CharSequence value);
}
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,7 @@
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 datadog.context.propagation.CompositePropagator.CarrierCache;
import java.util.ArrayList;
Expand Down Expand Up @@ -81,6 +82,103 @@ void keepsHeaderConstantsPastItsInitialCapacity() {
}
}

@Test
void keepsTransientValuesUntilReadAsStrings() {
CarrierCache cache = new CarrierCache(CarrierKeys.of(HeaderSchema.TRACEPARENT));
StringBuilder view = new StringBuilder("123");
cache.accept("traceparent", "tp");
cache.acceptTransient(HeaderSchema.X_DATADOG_TRACE_ID, "x-datadog-trace-id", view);

assertSame(HeaderSchema.X_DATADOG_TRACE_ID, cache.header(1));
assertSame(view, cache.valueView(1));
assertEquals("tp", cache.valueView(0));
// reading it as a String copies it once, and keeps the copy
String copy = cache.value(1);
assertEquals("123", copy);
view.setLength(0);
assertSame(copy, cache.value(1));
assertSame(copy, cache.valueView(1));
}

@Test
void visitsTransientValuesAsStrings() {
CarrierCache cache = new CarrierCache();
cache.acceptTransient(
HeaderSchema.X_DATADOG_PARENT_ID, "x-datadog-parent-id", "456x".subSequence(0, 3));
List<Object> seen = new ArrayList<>();
cache.forEachKeyValue(cache, (key, value) -> seen.add(value));
assertEquals(1, seen.size());
assertEquals("456", seen.get(0));
assertTrue(seen.get(0) instanceof String);
}

@Test
void keepsTransientValuesPastItsInitialCapacity() {
CarrierCache cache = new CarrierCache();
for (int i = 0; i < 20; i++) {
if (i % 2 == 0) {
cache.acceptTransient(HeaderSchema.X_DATADOG_TRACE_ID, "t" + i, new StringBuilder("v" + i));
} else {
cache.accept("k" + i, "v" + i);
}
}
for (int i = 0; i < 20; i++) {
assertEquals("v" + i, cache.value(i));
assertEquals(i % 2 == 0 ? HeaderSchema.X_DATADOG_TRACE_ID : null, cache.header(i));
}
}

@Test
void transientValueFirstThenStrings() {
CarrierCache cache = new CarrierCache();
cache.accept("a", "1");
cache.acceptTransient(HeaderSchema.X_DATADOG_TRACE_ID, "b", new StringBuilder("2"));
cache.accept("c", "3");
assertEquals("1", cache.valueView(0));
assertEquals("3", cache.valueView(2));
assertEquals("2", cache.value(1));
}

@Test
void nullValuesWithAndWithoutViews() {
CarrierCache cache = new CarrierCache();
cache.accept("a", null);
assertNull(cache.value(0));
assertNull(cache.valueView(0));
cache.acceptTransient(HeaderSchema.X_DATADOG_TRACE_ID, "b", new StringBuilder("2"));
cache.accept("c", null);
assertNull(cache.value(2));
assertNull(cache.valueView(2));
assertNull(cache.value(0));
}

@Test
void indexedCarrierViewsDefaultToValues() {
IndexedCarrier carrier =
new IndexedCarrier() {
@Override
public int size() {
return 1;
}

@Override
public String key(int index) {
return "k";
}

@Override
public String value(int index) {
return "v";
}

@Override
public HeaderSchema header(int index) {
return null;
}
};
assertEquals("v", carrier.valueView(0));
}

@Test
void emptyCache() {
CarrierCache cache = new CarrierCache();
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -48,6 +48,23 @@ void ordinalsFitInAByte() {
assertTrue(HeaderSchema.count() < Byte.MAX_VALUE);
}

@Test
void onlyDatadogIdHeadersAreParseOnly() {
Set<HeaderSchema> parseOnly = new HashSet<>();
for (HeaderSchema header : HeaderSchema.values()) {
if (header.isParseOnly()) {
parseOnly.add(header);
}
}
assertEquals(
new HashSet<>(
java.util.Arrays.asList(
HeaderSchema.X_DATADOG_TRACE_ID,
HeaderSchema.X_DATADOG_PARENT_ID,
HeaderSchema.X_DATADOG_SAMPLING_PRIORITY)),
parseOnly);
}

@Test
void lookupsByNameAndOrdinal() {
assertEquals(HeaderSchema.values().length, HeaderSchema.count());
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -90,6 +90,19 @@ default CarrierKeys keys() {
default void cleanup() {}
}

/**
* Hands pair {@code i} of {@code indexed} to {@code classifier}: a transient view through {@link
* AgentPropagation.KeyClassifier#acceptTransient}, a {@code String} through {@code accept}.
*/
static boolean acceptIndexed(
AgentPropagation.KeyClassifier classifier, IndexedCarrier indexed, int i) {
CharSequence value = indexed.valueView(i);
if (value == null || value instanceof String) {
return classifier.accept(indexed.header(i), indexed.key(i), (String) value);
}
return classifier.acceptTransient(indexed.header(i), indexed.key(i), value);
}

public static Injector createInjector(
Config config,
Set<TracePropagationStyle> styles,
Expand Down Expand Up @@ -439,7 +452,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.header(i), indexed.key(i), indexed.value(i));
acceptIndexed(classifier, indexed, i);
}
return;
}
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -92,7 +92,7 @@ private static <C> AgentPropagation.ContextVisitor<C> toContextVisitor(
// 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));
HttpCodec.acceptIndexed(classifier, indexed, i);
}
} else {
visitor.forEachKeyValue(carrier, classifier::accept);
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -252,13 +252,23 @@ public String value(int index) {
public HeaderSchema header(int index) {
return headers.get(index);
}

/** Parse-only values as views that aren't {@code String}s, as a byte carrier hands them. */
@Override
public CharSequence valueView(int index) {
HeaderSchema header = headers.get(index);
String value = values.get(index);
return header != null && header.isParseOnly() && value != null
? new StringBuilder(value)
: value;
}
}

/** Visits an {@link Indexed} carrier, handing each key's constant to the classifier. */
static final AgentPropagation.ContextVisitor<Indexed> WITH_HEADERS =
(carrier, classifier) -> {
for (int i = 0; i < carrier.size(); i++) {
if (!classifier.accept(carrier.header(i), carrier.key(i), carrier.value(i))) {
if (!HttpCodec.acceptIndexed(classifier, carrier, i)) {
return;
}
}
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -69,6 +69,19 @@ default <T> boolean accept(String key, T value, Function<T, String> transformer)
default boolean accept(HeaderSchema header, String key, String value) {
return accept(key, value);
}

/**
* Variant of {@link #accept(HeaderSchema, String, String)} for a value handed as a transient
* view (see {@code TransientValueConsumer}), valid only during this call: a classifier that
* overrides this parses it, or copies it ({@code toString()}) to keep it, and never keeps or
* hands on the view. The default copies it and calls {@link #accept(HeaderSchema, String,
* String)}.
*
* @return {@code false} to stop iteration, {@code true} to continue
*/
default boolean acceptTransient(HeaderSchema header, String key, CharSequence value) {
return accept(header, key, value == null ? null : value.toString());
}
}

public interface ContextVisitor<C> extends CarrierVisitor<C> {
Expand Down
Loading