open-telemetry
/
opentelemetry-java
mirror of https://github.com/open-telemetry/opentelemetry-java.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SpanContext hides the TraceId/SpanId implementations (#1594) 

*  This is a combination of 2 commits.
 This is the 1st commit message:

WIP on converting to String-based SpanContext

don't hand out the byte arrays publicly, but require making copies

make sure to hand out fresh invalid byte arrays.

Use strings for span and trace ids.

Switch over to CharSequence instead of String for the ids

Fix a couple of places that were casting to String

Add some simple wrappers for the generated longs to save converting until the last moment to the character-based representation.

introduce a reusable threadlocal char buffer for generating random ids.

update for changes from upstream

Change the SpanContext to store the ids as Strings internally
Change the id access methods on SpanContext to be clearly labeled as the base16 representations
Add a new create method that allows specifying offsets for traceId and spanId CharSequences

Provide an option for creating a SpanContext from longs or Strings, optionally.

fix a typo

update from upstream

 The commit message #2 will be skipped:

 don't hand out the byte arrays publicly, but require making copies

* WIP on converting to String-based SpanContext

* Update the SpanContext to only store Strings internally for Trace and Span ids.

* remove dead files

* cleanup some CharSequence usages to String

* Update api/src/main/java/io/opentelemetry/trace/BigendianEncoding.java

Co-authored-by: Anuraag Agrawal <anuraaga@gmail.com>

* Update extensions/trace_propagators/src/main/java/io/opentelemetry/extensions/trace/propagation/B3PropagatorInjectorSingleHeader.java

Co-authored-by: Anuraag Agrawal <anuraaga@gmail.com>

* Update api/src/main/java/io/opentelemetry/trace/SpanId.java

Co-authored-by: Anuraag Agrawal <anuraaga@gmail.com>

* Update api/src/main/java/io/opentelemetry/trace/TraceId.java

Co-authored-by: Anuraag Agrawal <anuraaga@gmail.com>

* updates from PR suggestion fubars

* some cleanup from PR feedback

* Switch back to String from CharSequence

* Get rid of the overload with the offsets

* Lots of bits of cleanup from PR feedback.

* more renaming of base16 to hex

Co-authored-by: Anuraag Agrawal <anuraaga@gmail.com>
This commit is contained in:
John Watson 2020-09-03 10:03:41 -07:00 committed by GitHub
parent 304f55a7ab
commit 485cc52c6f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
69 changed files with 703 additions and 837 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java
View File

@ -20,9 +20,7 @@ import io.grpc.Context;
import io.opentelemetry.context.propagation.TextMapPropagator.Setter;
import io.opentelemetry.trace.DefaultSpan;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
import io.opentelemetry.trace.TracingContextUtils;
import java.util.ArrayList;
@ -83,11 +81,7 @@ public class HttpTraceContextInjectBenchmark {
byte sampledTraceOptionsBytes = 1;
TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes);
TraceState traceStateDefault = TraceState.builder().build();
return SpanContext.create(
TraceId.fromLowerBase16(traceId, 0),
SpanId.fromLowerBase16(spanId, 0),
sampledTraceOptions,
traceStateDefault);
return SpanContext.create(traceId, spanId, sampledTraceOptions, traceStateDefault);
}
private static List<Context> createContexts(List<SpanContext> spanContexts) {

35
api/src/main/java/io/opentelemetry/trace/BigendianEncoding.java
View File

@ -138,6 +138,14 @@ final class BigendianEncoding {
byteToBase16(value, dest, destOffset);
}
static byte[] bytesFromBase16(CharSequence value, int offset, int length) {
byte[] result = new byte[length / 2];
for (int i = 0; i < length; i += 2) {
result[i / 2] = byteFromBase16String(value, offset + i);
}
return result;
}
/**
* Decodes the specified two character sequence, and returns the resulting {@code byte}.
*
@ -165,5 +173,32 @@ final class BigendianEncoding {
dest[destOffset + 1] = ENCODING[b | 0x100];
}
static boolean isValidBase16String(CharSequence value) {
for (int i = 0; i < value.length(); i++) {
char b = value.charAt(i);
// 48..57 && 97..102 are valid
if (!isDigit(b) && !isLowercaseHexCharacter(b)) {
return false;
}
}
return true;
}
private static boolean isLowercaseHexCharacter(char b) {
return 97 <= b && b <= 102;
}
private static boolean isDigit(char b) {
return 48 <= b && b <= 57;
}
private BigendianEncoding() {}
static String toLowerBase16(byte[] bytes) {
char[] chars = new char[bytes.length * 2];
for (int i = 0; i < bytes.length; i++) {
byteToBase16(bytes[i], chars, i * 2);
}
return new String(chars);
}
}

64
api/src/main/java/io/opentelemetry/trace/SpanContext.java
View File

@ -17,6 +17,7 @@
package io.opentelemetry.trace;
import com.google.auto.value.AutoValue;
import com.google.auto.value.extension.memoized.Memoized;
import javax.annotation.concurrent.Immutable;
/**
@ -51,41 +52,68 @@ public abstract class SpanContext {
/**
* Creates a new {@code SpanContext} with the given identifiers and options.
*
* @param traceId the trace identifier of the span context.
* @param spanId the span identifier of the span context.
* @param traceIdHex the trace identifier of the span context.
* @param spanIdHex the span identifier of the span context.
* @param traceFlags the trace options for the span context.
* @param traceState the trace state for the span context.
* @return a new {@code SpanContext} with the given identifiers and options.
* @since 0.1.0
*/
public static SpanContext create(
TraceId traceId, SpanId spanId, TraceFlags traceFlags, TraceState traceState) {
return new AutoValue_SpanContext(traceId, spanId, traceFlags, traceState, /* remote=*/ false);
String traceIdHex, String spanIdHex, TraceFlags traceFlags, TraceState traceState) {
return create(traceIdHex, spanIdHex, traceFlags, traceState, /* remote=*/ false);
}
private static SpanContext create(
String traceIdHex,
String spanIdHex,
TraceFlags traceFlags,
TraceState traceState,
boolean remote) {
return new AutoValue_SpanContext(
traceIdHex, spanIdHex, traceFlags, traceState, /* remote$=*/ remote);
}
/**
* Creates a new {@code SpanContext} that was propagated from a remote parent, with the given
* identifiers and options.
*
* @param traceId the trace identifier of the span context.
* @param spanId the span identifier of the span context.
* @param traceIdHex the trace identifier of the span context.
* @param spanIdHex the span identifier of the span context.
* @param traceFlags the trace options for the span context.
* @param traceState the trace state for the span context.
* @return a new {@code SpanContext} with the given identifiers and options.
* @since 0.1.0
*/
public static SpanContext createFromRemoteParent(
TraceId traceId, SpanId spanId, TraceFlags traceFlags, TraceState traceState) {
return new AutoValue_SpanContext(traceId, spanId, traceFlags, traceState, /* remote=*/ true);
String traceIdHex, String spanIdHex, TraceFlags traceFlags, TraceState traceState) {
return create(traceIdHex, spanIdHex, traceFlags, traceState, /* remote=*/ true);
}
abstract String getTraceIdHex();
abstract String getSpanIdHex();
/**
* Returns the trace identifier associated with this {@code SpanContext}.
*
* @return the trace identifier associated with this {@code SpanContext}.
* @since 0.1.0
*/
public abstract TraceId getTraceId();
public String getTraceIdAsHexString() {
return getTraceIdHex();
}
/**
* Returns the byte[] representation of the trace identifier associated with this {@link
* SpanContext}.
*
* @since 0.8.0
*/
@Memoized
public byte[] getTraceIdBytes() {
return TraceId.bytesFromHex(getTraceIdHex(), 0);
}
/**
* Returns the span identifier associated with this {@code SpanContext}.
@ -93,7 +121,20 @@ public abstract class SpanContext {
* @return the span identifier associated with this {@code SpanContext}.
* @since 0.1.0
*/
public abstract SpanId getSpanId();
public String getSpanIdAsHexString() {
return getSpanIdHex();
}
/**
* Returns the byte[] representation of the span identifier associated with this {@link
* SpanContext}.
*
* @since 0.8.0
*/
@Memoized
public byte[] getSpanIdBytes() {
return SpanId.bytesFromHex(getSpanIdHex(), 0);
}
/**
* Returns the {@code TraceFlags} associated with this {@code SpanContext}.
@ -117,8 +158,9 @@ public abstract class SpanContext {
* @return {@code true} if this {@code SpanContext} is valid.
* @since 0.1.0
*/
@Memoized
public boolean isValid() {
return getTraceId().isValid() && getSpanId().isValid();
return TraceId.isValid(getTraceIdHex()) && SpanId.isValid(getSpanIdHex());
}
/**

155
api/src/main/java/io/opentelemetry/trace/SpanId.java
View File

@ -16,43 +16,25 @@
package io.opentelemetry.trace;
import io.opentelemetry.internal.Utils;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
/**
* A class that represents a span identifier. A valid span identifier is an 8-byte array with at
* least one non-zero byte.
* Helper methods for dealing with a span identifier. A valid span identifier is an 8-byte array
* with at least one non-zero byte. In base-16 representation, a 16 character hex String, where at
* least one of the characters is not a '0'.
*
* @since 0.1.0
*/
@Immutable
public final class SpanId implements Comparable<SpanId> {
public final class SpanId {
private static final ThreadLocal<char[]> charBuffer = new ThreadLocal<>();
private static final int SIZE = 8;
private static final int BASE16_SIZE = 2 * SIZE;
private static final long INVALID_ID = 0;
private static final SpanId INVALID = new SpanId(INVALID_ID);
private static final int HEX_SIZE = 2 * SIZE;
// The internal representation of the SpanId.
private final long id;
private static final String INVALID = "0000000000000000";
/**
* Constructs a {@code SpanId} whose representation is specified by a long value.
*
* <p>There is no restriction on the specified value, other than the already established validity
* rules applying to {@code SpanId}. Specifying 0 for this value will effectively make the new
* {@code SpanId} invalid.
*
* <p>This is equivalent to calling {@link #fromBytes(byte[], int)} with the specified value
* stored as big-endian.
*
* @param id the long representation of the {@code TraceId}.
* @since 0.1.0
*/
public SpanId(long id) {
this.id = id;
}
private SpanId() {}
/**
* Returns the size in bytes of the {@code SpanId}.
@ -64,47 +46,39 @@ public final class SpanId implements Comparable<SpanId> {
return SIZE;
}
/**
* Returns the length of the base16 (hex) representation of the {@code SpanId}.
*
* @since 0.8.0
*/
public static int getHexLength() {
return HEX_SIZE;
}
/**
* Returns the invalid {@code SpanId}. All bytes are 0.
*
* @return the invalid {@code SpanId}.
* @since 0.1.0
*/
public static SpanId getInvalid() {
public static String getInvalid() {
return INVALID;
}
/**
* Returns a {@code SpanId} whose representation is copied from the {@code src} beginning at the
* {@code srcOffset} offset.
*
* @param src the buffer where the representation of the {@code SpanId} is copied.
* @param srcOffset the offset in the buffer where the representation of the {@code SpanId}
* begins.
* @return a {@code SpanId} whose representation is copied from the buffer.
* @throws NullPointerException if {@code src} is null.
* @throws IndexOutOfBoundsException if {@code srcOffset+SpanId.getSize()} is greater than {@code
* src.length}.
* @since 0.1.0
*/
public static SpanId fromBytes(byte[] src, int srcOffset) {
Utils.checkNotNull(src, "src");
return new SpanId(BigendianEncoding.longFromByteArray(src, srcOffset));
/** Generate a valid {@link SpanId} from the given long value. */
public static String fromLong(long id) {
char[] result = getTemporaryBuffer();
BigendianEncoding.longToBase16String(id, result, 0);
return new String(result);
}
/**
* Copies the byte array representations of the {@code SpanId} into the {@code dest} beginning at
* the {@code destOffset} offset.
*
* @param dest the destination buffer.
* @param destOffset the starting offset in the destination buffer.
* @throws NullPointerException if {@code dest} is null.
* @throws IndexOutOfBoundsException if {@code destOffset+SpanId.getSize()} is greater than {@code
* dest.length}.
* @since 0.1.0
*/
public void copyBytesTo(byte[] dest, int destOffset) {
BigendianEncoding.longToByteArray(id, dest, destOffset);
private static char[] getTemporaryBuffer() {
char[] chars = charBuffer.get();
if (chars == null) {
chars = new char[HEX_SIZE];
charBuffer.set(chars);
}
return chars;
}
/**
@ -119,23 +93,8 @@ public final class SpanId implements Comparable<SpanId> {
* srcOffset}.
* @since 0.1.0
*/
public static SpanId fromLowerBase16(CharSequence src, int srcOffset) {
Utils.checkNotNull(src, "src");
return new SpanId(BigendianEncoding.longFromBase16String(src, srcOffset));
}
/**
* Copies the lowercase base16 representations of the {@code SpanId} into the {@code dest}
* beginning at the {@code destOffset} offset.
*
* @param dest the destination buffer.
* @param destOffset the starting offset in the destination buffer.
* @throws IndexOutOfBoundsException if {@code destOffset + 2 * SpanId.getSize()} is greater than
* {@code dest.length}.
* @since 0.1.0
*/
public void copyLowerBase16To(char[] dest, int destOffset) {
BigendianEncoding.longToBase16String(id, dest, destOffset);
public static byte[] bytesFromHex(String src, int srcOffset) {
return BigendianEncoding.bytesFromBase16(src, srcOffset, HEX_SIZE);
}
/**
@ -145,50 +104,14 @@ public final class SpanId implements Comparable<SpanId> {
* @return {@code true} if the span identifier is valid.
* @since 0.1.0
*/
public boolean isValid() {
return id != INVALID_ID;
public static boolean isValid(String spanId) {
return (spanId.length() == HEX_SIZE)
&& !INVALID.equals(spanId)
&& BigendianEncoding.isValidBase16String(spanId);
}
/**
* Returns the lowercase base16 encoding of this {@code SpanId}.
*
* @return the lowercase base16 encoding of this {@code SpanId}.
* @since 0.1.0
*/
public String toLowerBase16() {
char[] chars = new char[BASE16_SIZE];
copyLowerBase16To(chars, 0);
return new String(chars);
}
@Override
public boolean equals(@Nullable Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof SpanId)) {
return false;
}
SpanId that = (SpanId) obj;
return id == that.id;
}
@Override
public int hashCode() {
// Copied from Long.hashCode in java8.
return (int) (id ^ (id >>> 32));
}
@Override
public String toString() {
return "SpanId{spanId=" + toLowerBase16() + "}";
}
@Override
public int compareTo(SpanId that) {
// Copied from Long.compare in java8.
return (id < that.id) ? -1 : ((id == that.id) ? 0 : 1);
/** Encode the bytes as base-16 (hex), padded with '0's on the left. */
public static String bytesToHex(byte[] spanId) {
return BigendianEncoding.toLowerBase16(spanId);
}
}

191
api/src/main/java/io/opentelemetry/trace/TraceId.java
View File

@ -17,26 +17,53 @@
package io.opentelemetry.trace;
import io.opentelemetry.internal.Utils;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
/**
* A class that represents a trace identifier. A valid trace identifier is a 16-byte array with at
* least one non-zero byte.
* Helper methods for dealing with a trace identifier. A valid trace identifier is a 16-byte array
* with at least one non-zero byte. In base-16 representation, a 32 character hex String, where at
* least one of the characters is not a '0'.
*
* @since 0.1.0
*/
@Immutable
public final class TraceId implements Comparable<TraceId> {
public final class TraceId {
private static final ThreadLocal<char[]> charBuffer = new ThreadLocal<>();
private static final int SIZE = 16;
private static final int BASE16_SIZE = 2 * BigendianEncoding.LONG_BASE16;
private static final long INVALID_ID = 0;
private static final TraceId INVALID = new TraceId(INVALID_ID, INVALID_ID);
private static final int SIZE_IN_BYTES = 16;
private static final int HEX_SIZE = 2 * BigendianEncoding.LONG_BASE16;
private static final String INVALID = "00000000000000000000000000000000";
// The internal representation of the TraceId.
private final long idHi;
private final long idLo;
private TraceId() {}
/**
* Returns the size in bytes of the {@code TraceId}.
*
* @return the size in bytes of the {@code TraceId}.
* @since 0.1.0
*/
public static int getSize() {
return SIZE_IN_BYTES;
}
/**
* Returns the length of the base16 (hex) representation of the {@code TraceId}.
*
* @since 0.8.0
*/
public static int getHexLength() {
return HEX_SIZE;
}
/**
* Returns the invalid {@code TraceId}. All bytes are '\0'.
*
* @return the invalid {@code TraceId}.
* @since 0.1.0
*/
public static String getInvalid() {
return INVALID;
}
/**
* Constructs a {@code TraceId} whose representation is specified by two long values representing
@ -46,72 +73,27 @@ public final class TraceId implements Comparable<TraceId> {
* rules applying to {@code TraceId}. Specifying 0 for both values will effectively make the new
* {@code TraceId} invalid.
*
* <p>This is equivalent to calling {@link #fromBytes(byte[], int)} with the specified values
* stored as big-endian.
* <p>This is equivalent to calling {@link #bytesToHex(byte[])} with the specified values stored
* as big-endian.
*
* @param idHi the higher part of the {@code TraceId}.
* @param idLo the lower part of the {@code TraceId}.
* @since 0.1.0
*/
public TraceId(long idHi, long idLo) {
this.idHi = idHi;
this.idLo = idLo;
public static String fromLongs(long idHi, long idLo) {
char[] chars = getTemporaryBuffer();
BigendianEncoding.longToBase16String(idHi, chars, 0);
BigendianEncoding.longToBase16String(idLo, chars, 16);
return new String(chars);
}
/**
* Returns the size in bytes of the {@code TraceId}.
*
* @return the size in bytes of the {@code TraceId}.
* @since 0.1.0
*/
public static int getSize() {
return SIZE;
}
/**
* Returns the invalid {@code TraceId}. All bytes are '\0'.
*
* @return the invalid {@code TraceId}.
* @since 0.1.0
*/
public static TraceId getInvalid() {
return INVALID;
}
/**
* Returns a {@code TraceId} whose representation is copied from the {@code src} beginning at the
* {@code srcOffset} offset.
*
* @param src the buffer where the representation of the {@code TraceId} is copied.
* @param srcOffset the offset in the buffer where the representation of the {@code TraceId}
* begins.
* @return a {@code TraceId} whose representation is copied from the buffer.
* @throws NullPointerException if {@code src} is null.
* @throws IndexOutOfBoundsException if {@code srcOffset+TraceId.getSize()} is greater than {@code
* src.length}.
* @since 0.1.0
*/
public static TraceId fromBytes(byte[] src, int srcOffset) {
Utils.checkNotNull(src, "src");
return new TraceId(
BigendianEncoding.longFromByteArray(src, srcOffset),
BigendianEncoding.longFromByteArray(src, srcOffset + BigendianEncoding.LONG_BYTES));
}
/**
* Copies the byte array representations of the {@code TraceId} into the {@code dest} beginning at
* the {@code destOffset} offset.
*
* @param dest the destination buffer.
* @param destOffset the starting offset in the destination buffer.
* @throws NullPointerException if {@code dest} is null.
* @throws IndexOutOfBoundsException if {@code destOffset+TraceId.getSize()} is greater than
* {@code dest.length}.
* @since 0.1.0
*/
public void copyBytesTo(byte[] dest, int destOffset) {
BigendianEncoding.longToByteArray(idHi, dest, destOffset);
BigendianEncoding.longToByteArray(idLo, dest, destOffset + BigendianEncoding.LONG_BYTES);
private static char[] getTemporaryBuffer() {
char[] chars = charBuffer.get();
if (chars == null) {
chars = new char[HEX_SIZE];
charBuffer.set(chars);
}
return chars;
}
/**
@ -126,11 +108,9 @@ public final class TraceId implements Comparable<TraceId> {
* srcOffset}.
* @since 0.1.0
*/
public static TraceId fromLowerBase16(CharSequence src, int srcOffset) {
public static byte[] bytesFromHex(String src, int srcOffset) {
Utils.checkNotNull(src, "src");
return new TraceId(
BigendianEncoding.longFromBase16String(src, srcOffset),
BigendianEncoding.longFromBase16String(src, srcOffset + BigendianEncoding.LONG_BASE16));
return BigendianEncoding.bytesFromBase16(src, srcOffset, HEX_SIZE);
}
/**
@ -143,9 +123,11 @@ public final class TraceId implements Comparable<TraceId> {
* {@code dest.length}.
* @since 0.1.0
*/
public void copyLowerBase16To(char[] dest, int destOffset) {
BigendianEncoding.longToBase16String(idHi, dest, destOffset);
BigendianEncoding.longToBase16String(idLo, dest, destOffset + BASE16_SIZE / 2);
public static void copyHexInto(byte[] traceId, char[] dest, int destOffset) {
BigendianEncoding.longToBase16String(
BigendianEncoding.longFromByteArray(traceId, 0), dest, destOffset);
BigendianEncoding.longToBase16String(
BigendianEncoding.longFromByteArray(traceId, 8), dest, destOffset + 16);
}
/**
@ -155,8 +137,10 @@ public final class TraceId implements Comparable<TraceId> {
* @return {@code true} if the {@code TraceId} is valid.
* @since 0.1.0
*/
public boolean isValid() {
return idHi != INVALID_ID || idLo != INVALID_ID;
public static boolean isValid(CharSequence traceId) {
return (traceId.length() == HEX_SIZE)
&& !INVALID.contentEquals(traceId)
&& BigendianEncoding.isValidBase16String(traceId);
}
/**
@ -165,26 +149,12 @@ public final class TraceId implements Comparable<TraceId> {
* @return the lowercase base16 encoding of this {@code TraceId}.
* @since 0.1.0
*/
public String toLowerBase16() {
char[] chars = new char[BASE16_SIZE];
copyLowerBase16To(chars, 0);
public static String bytesToHex(byte[] traceId) {
char[] chars = new char[HEX_SIZE];
copyHexInto(traceId, chars, 0);
return new String(chars);
}
@Override
public boolean equals(@Nullable Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof TraceId)) {
return false;
}
TraceId that = (TraceId) obj;
return idHi == that.idHi && idLo == that.idLo;
}
/**
* Returns the rightmost 8 bytes of the trace-id as a long value. This is used in
* ProbabilitySampler.
@ -193,32 +163,7 @@ public final class TraceId implements Comparable<TraceId> {
*
* @return the rightmost 8 bytes of the trace-id as a long value.
*/
public long getTraceRandomPart() {
return idLo;
}
@Override
public int hashCode() {
// Copied from Arrays.hashCode(long[])
int result = 1;
result = 31 * result + ((int) (idHi ^ (idHi >>> 32)));
result = 31 * result + ((int) (idLo ^ (idLo >>> 32)));
return result;
}
@Override
public String toString() {
return "TraceId{traceId=" + toLowerBase16() + "}";
}
@Override
public int compareTo(TraceId that) {
if (idHi == that.idHi) {
if (idLo == that.idLo) {
return 0;
}
return idLo < that.idLo ? -1 : 1;
}
return idHi < that.idHi ? -1 : 1;
public static long getTraceIdRandomPart(CharSequence traceId) {
return BigendianEncoding.longFromBase16String(traceId, BigendianEncoding.LONG_BASE16);
}
}

34
api/src/main/java/io/opentelemetry/trace/propagation/HttpTraceContext.java
View File

@ -55,8 +55,8 @@ public class HttpTraceContext implements TextMapPropagator {
private static final int VERSION_SIZE = 2;
private static final char TRACEPARENT_DELIMITER = '-';
private static final int TRACEPARENT_DELIMITER_SIZE = 1;
private static final int TRACE_ID_HEX_SIZE = 2 * TraceId.getSize();
private static final int SPAN_ID_HEX_SIZE = 2 * SpanId.getSize();
private static final int TRACE_ID_HEX_SIZE = TraceId.getHexLength();
private static final int SPAN_ID_HEX_SIZE = SpanId.getHexLength();
private static final int TRACE_OPTION_HEX_SIZE = 2 * TraceFlags.getSize();
private static final int TRACE_ID_OFFSET = VERSION_SIZE + TRACEPARENT_DELIMITER_SIZE;
private static final int SPAN_ID_OFFSET =
@ -94,9 +94,19 @@ public class HttpTraceContext implements TextMapPropagator {
chars[0] = VERSION.charAt(0);
chars[1] = VERSION.charAt(1);
chars[2] = TRACEPARENT_DELIMITER;
spanContext.getTraceId().copyLowerBase16To(chars, TRACE_ID_OFFSET);
String traceId = spanContext.getTraceIdAsHexString();
for (int i = 0; i < traceId.length(); i++) {
chars[TRACE_ID_OFFSET + i] = traceId.charAt(i);
}
chars[SPAN_ID_OFFSET - 1] = TRACEPARENT_DELIMITER;
spanContext.getSpanId().copyLowerBase16To(chars, SPAN_ID_OFFSET);
String spanId = spanContext.getSpanIdAsHexString();
for (int i = 0; i < spanId.length(); i++) {
chars[SPAN_ID_OFFSET + i] = spanId.charAt(i);
}
chars[TRACE_OPTION_OFFSET - 1] = TRACEPARENT_DELIMITER;
spanContext.getTraceFlags().copyLowerBase16To(chars, TRACE_OPTION_OFFSET);
setter.set(carrier, TRACE_PARENT, new String(chars, 0, TRACEPARENT_HEADER_SIZE));
@ -152,8 +162,8 @@ public class HttpTraceContext implements TextMapPropagator {
try {
TraceState traceState = extractTraceState(traceStateHeader);
return SpanContext.createFromRemoteParent(
contextFromParentHeader.getTraceId(),
contextFromParentHeader.getSpanId(),
contextFromParentHeader.getTraceIdAsHexString(),
contextFromParentHeader.getSpanIdAsHexString(),
contextFromParentHeader.getTraceFlags(),
traceState);
} catch (IllegalArgumentException e) {
@ -178,10 +188,14 @@ public class HttpTraceContext implements TextMapPropagator {
}
try {
TraceId traceId = TraceId.fromLowerBase16(traceparent, TRACE_ID_OFFSET);
SpanId spanId = SpanId.fromLowerBase16(traceparent, SPAN_ID_OFFSET);
TraceFlags traceFlags = TraceFlags.fromLowerBase16(traceparent, TRACE_OPTION_OFFSET);
return SpanContext.createFromRemoteParent(traceId, spanId, traceFlags, TRACE_STATE_DEFAULT);
String traceId =
traceparent.substring(TRACE_ID_OFFSET, TRACE_ID_OFFSET + TraceId.getHexLength());
String spanId = traceparent.substring(SPAN_ID_OFFSET, SPAN_ID_OFFSET + SpanId.getHexLength());
if (TraceId.isValid(traceId) && SpanId.isValid(spanId)) {
TraceFlags traceFlags = TraceFlags.fromLowerBase16(traceparent, TRACE_OPTION_OFFSET);
return SpanContext.createFromRemoteParent(traceId, spanId, traceFlags, TRACE_STATE_DEFAULT);
}
return SpanContext.getInvalid();
} catch (IllegalArgumentException e) {
logger.info("Unparseable traceparent header. Returning INVALID span context.");
return SpanContext.getInvalid();

10
api/src/test/java/io/opentelemetry/trace/BigendianEncodingTest.java
View File

@ -147,7 +147,7 @@ class BigendianEncodingTest {
}
@Test
void longFromBase16String_UnrecongnizedCharacters() {
void longFromBase16String_UnrecognizedCharacters() {
// These contain bytes not in the decoding.
assertThrows(
IllegalArgumentException.class,
@ -155,6 +155,14 @@ class BigendianEncodingTest {
"invalid character g");
}
@Test
void validHex() {
assertThat(BigendianEncoding.isValidBase16String("abcdef1234567890")).isTrue();
assertThat(BigendianEncoding.isValidBase16String("abcdefg1234567890")).isFalse();
assertThat(BigendianEncoding.isValidBase16String("<abcdef1234567890")).isFalse();
assertThat(BigendianEncoding.isValidBase16String("abcdef1234567890B")).isFalse();
}
@Test
void longFromBase16String() {
assertThat(BigendianEncoding.longFromBase16String(CharBuffer.wrap(FIRST_CHAR_ARRAY), 0))

5
api/src/test/java/io/opentelemetry/trace/DefaultTracerTest.java
View File

@ -33,10 +33,11 @@ class DefaultTracerTest {
private static final String SPAN_NAME = "MySpanName";
private static final byte[] firstBytes =
new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'a'};
private static final byte[] spanBytes = new byte[] {0, 0, 0, 0, 0, 0, 0, 'a'};
private static final SpanContext spanContext =
SpanContext.create(
TraceId.fromBytes(firstBytes, 0),
SpanId.fromBytes(firstBytes, 8),
TraceId.bytesToHex(firstBytes),
SpanId.bytesToHex(spanBytes),
TraceFlags.getDefault(),
TraceState.getDefault());

41
api/src/test/java/io/opentelemetry/trace/SpanContextTest.java
View File

@ -24,38 +24,39 @@ import org.junit.jupiter.api.Test;
class SpanContextTest {
private static final byte[] firstTraceIdBytes =
new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'a'};
private static final String FIRST_TRACE_ID = TraceId.bytesToHex(firstTraceIdBytes);
private static final byte[] secondTraceIdBytes =
new byte[] {0, 0, 0, 0, 0, 0, 0, '0', 0, 0, 0, 0, 0, 0, 0, 0};
private static final String SECOND_TRACE_ID = TraceId.bytesToHex(secondTraceIdBytes);
private static final byte[] firstSpanIdBytes = new byte[] {0, 0, 0, 0, 0, 0, 0, 'a'};
private static final String FIRST_SPAN_ID = SpanId.bytesToHex(firstSpanIdBytes);
private static final byte[] secondSpanIdBytes = new byte[] {'0', 0, 0, 0, 0, 0, 0, 0};
private static final String SECOND_SPAN_ID = SpanId.bytesToHex(secondSpanIdBytes);
private static final TraceState FIRST_TRACE_STATE =
TraceState.builder().set("foo", "bar").build();
private static final TraceState SECOND_TRACE_STATE =
TraceState.builder().set("foo", "baz").build();
private static final TraceState EMPTY_TRACE_STATE = TraceState.builder().build();
private static final SpanContext first =
SpanContext.create(
TraceId.fromBytes(firstTraceIdBytes, 0),
SpanId.fromBytes(firstSpanIdBytes, 0),
TraceFlags.getDefault(),
FIRST_TRACE_STATE);
SpanContext.create(FIRST_TRACE_ID, FIRST_SPAN_ID, TraceFlags.getDefault(), FIRST_TRACE_STATE);
private static final SpanContext second =
SpanContext.create(
TraceId.fromBytes(secondTraceIdBytes, 0),
SpanId.fromBytes(secondSpanIdBytes, 0),
SECOND_TRACE_ID,
SECOND_SPAN_ID,
TraceFlags.builder().setIsSampled(true).build(),
SECOND_TRACE_STATE);
private static final SpanContext remote =
SpanContext.createFromRemoteParent(
TraceId.fromBytes(secondTraceIdBytes, 0),
SpanId.fromBytes(secondSpanIdBytes, 0),
SECOND_TRACE_ID,
SECOND_SPAN_ID,
TraceFlags.builder().setIsSampled(true).build(),
EMPTY_TRACE_STATE);
@Test
void invalidSpanContext() {
assertThat(SpanContext.getInvalid().getTraceId()).isEqualTo(TraceId.getInvalid());
assertThat(SpanContext.getInvalid().getSpanId()).isEqualTo(SpanId.getInvalid());
assertThat(SpanContext.getInvalid().getTraceIdAsHexString()).isEqualTo(TraceId.getInvalid());
assertThat(SpanContext.getInvalid().getSpanIdAsHexString()).isEqualTo(SpanId.getInvalid());
assertThat(SpanContext.getInvalid().getTraceFlags()).isEqualTo(TraceFlags.getDefault());
}
@ -64,18 +65,12 @@ class SpanContextTest {
assertThat(SpanContext.getInvalid().isValid()).isFalse();
assertThat(
SpanContext.create(
TraceId.fromBytes(firstTraceIdBytes, 0),
SpanId.getInvalid(),
TraceFlags.getDefault(),
EMPTY_TRACE_STATE)
FIRST_TRACE_ID, SpanId.getInvalid(), TraceFlags.getDefault(), EMPTY_TRACE_STATE)
.isValid())
.isFalse();
assertThat(
SpanContext.create(
TraceId.getInvalid(),
SpanId.fromBytes(firstSpanIdBytes, 0),
TraceFlags.getDefault(),
EMPTY_TRACE_STATE)
TraceId.getInvalid(), FIRST_SPAN_ID, TraceFlags.getDefault(), EMPTY_TRACE_STATE)
.isValid())
.isFalse();
assertThat(first.isValid()).isTrue();
@ -84,14 +79,14 @@ class SpanContextTest {
@Test
void getTraceId() {
assertThat(first.getTraceId()).isEqualTo(TraceId.fromBytes(firstTraceIdBytes, 0));
assertThat(second.getTraceId()).isEqualTo(TraceId.fromBytes(secondTraceIdBytes, 0));
assertThat(first.getTraceIdAsHexString()).isEqualTo(FIRST_TRACE_ID);
assertThat(second.getTraceIdAsHexString()).isEqualTo(SECOND_TRACE_ID);
}
@Test
void getSpanId() {
assertThat(first.getSpanId()).isEqualTo(SpanId.fromBytes(firstSpanIdBytes, 0));
assertThat(second.getSpanId()).isEqualTo(SpanId.fromBytes(secondSpanIdBytes, 0));
assertThat(first.getSpanIdAsHexString()).isEqualTo(FIRST_SPAN_ID);
assertThat(second.getSpanIdAsHexString()).isEqualTo(SECOND_SPAN_ID);
}
@Test

58
api/src/test/java/io/opentelemetry/trace/SpanIdTest.java
View File

@ -18,68 +18,48 @@ package io.opentelemetry.trace;
import static org.assertj.core.api.Assertions.assertThat;
import com.google.common.testing.EqualsTester;
import java.nio.ByteBuffer;
import java.util.Arrays;
import org.junit.jupiter.api.Test;
/** Unit tests for {@link SpanId}. */
class SpanIdTest {
private static final byte[] firstBytes = new byte[] {0, 0, 0, 0, 0, 0, 0, 'a'};
private static final byte[] secondBytes = new byte[] {(byte) 0xFF, 0, 0, 0, 0, 0, 0, 'A'};
private static final SpanId first = new SpanId(ByteBuffer.wrap(firstBytes).getLong());
private static final SpanId second = SpanId.fromBytes(secondBytes, 0);
@Test
void isValid() {
assertThat(SpanId.getInvalid().isValid()).isFalse();
assertThat(first.isValid()).isTrue();
assertThat(second.isValid()).isTrue();
assertThat(SpanId.isValid(SpanId.getInvalid())).isFalse();
assertThat(SpanId.isValid(SpanId.bytesToHex(firstBytes))).isTrue();
assertThat(SpanId.isValid(SpanId.bytesToHex(secondBytes))).isTrue();
assertThat(SpanId.isValid("000000000000z000")).isFalse();
}
@Test
void fromLowerBase16() {
assertThat(SpanId.fromLowerBase16("0000000000000000", 0)).isEqualTo(SpanId.getInvalid());
assertThat(SpanId.fromLowerBase16("0000000000000061", 0)).isEqualTo(first);
assertThat(SpanId.fromLowerBase16("ff00000000000041", 0)).isEqualTo(second);
assertThat(SpanId.bytesToHex(SpanId.bytesFromHex("0000000000000000", 0)))
.isEqualTo(SpanId.getInvalid());
assertThat(SpanId.bytesFromHex("0000000000000061", 0)).isEqualTo(firstBytes);
assertThat(SpanId.bytesFromHex("ff00000000000041", 0)).isEqualTo(secondBytes);
}
@Test
void fromLowerBase16_WithOffset() {
assertThat(SpanId.fromLowerBase16("XX0000000000000000AA", 2)).isEqualTo(SpanId.getInvalid());
assertThat(SpanId.fromLowerBase16("YY0000000000000061BB", 2)).isEqualTo(first);
assertThat(SpanId.fromLowerBase16("ZZff00000000000041CC", 2)).isEqualTo(second);
assertThat(SpanId.bytesToHex(SpanId.bytesFromHex("XX0000000000000000AA", 2)))
.isEqualTo(SpanId.getInvalid());
assertThat(SpanId.bytesFromHex("YY0000000000000061BB", 2)).isEqualTo(firstBytes);
assertThat(SpanId.bytesFromHex("ZZff00000000000041CC", 2)).isEqualTo(secondBytes);
}
@Test
void toLowerBase16() {
assertThat(SpanId.getInvalid().toLowerBase16()).isEqualTo("0000000000000000");
assertThat(first.toLowerBase16()).isEqualTo("0000000000000061");
assertThat(second.toLowerBase16()).isEqualTo("ff00000000000041");
}
@Test
void spanId_CompareTo() {
assertThat(first.compareTo(second)).isGreaterThan(0);
assertThat(second.compareTo(first)).isLessThan(0);
assertThat(first.compareTo(SpanId.fromBytes(firstBytes, 0))).isEqualTo(0);
}
@Test
void spanId_EqualsAndHashCode() {
EqualsTester tester = new EqualsTester();
tester.addEqualityGroup(SpanId.getInvalid(), SpanId.getInvalid());
tester.addEqualityGroup(
first, SpanId.fromBytes(Arrays.copyOf(firstBytes, firstBytes.length), 0));
tester.addEqualityGroup(
second, SpanId.fromBytes(Arrays.copyOf(secondBytes, secondBytes.length), 0));
tester.testEquals();
public void toLowerBase16() {
assertThat(SpanId.getInvalid()).isEqualTo("0000000000000000");
assertThat(SpanId.bytesToHex(firstBytes)).isEqualTo("0000000000000061");
assertThat(SpanId.bytesToHex(secondBytes)).isEqualTo("ff00000000000041");
}
@Test
void spanId_ToString() {
assertThat(SpanId.getInvalid().toString()).contains("0000000000000000");
assertThat(first.toString()).contains("0000000000000061");
assertThat(second.toString()).contains("ff00000000000041");
assertThat(SpanId.getInvalid()).contains("0000000000000000");
assertThat(SpanId.bytesToHex(firstBytes)).contains("0000000000000061");
assertThat(SpanId.bytesToHex(secondBytes)).contains("ff00000000000041");
}
}

75
api/src/test/java/io/opentelemetry/trace/TraceIdTest.java
View File

@ -18,9 +18,7 @@ package io.opentelemetry.trace;
import static org.assertj.core.api.Assertions.assertThat;
import com.google.common.testing.EqualsTester;
import java.nio.ByteBuffer;
import java.util.Arrays;
import org.junit.jupiter.api.Test;
/** Unit tests for {@link TraceId}. */
@ -29,21 +27,24 @@ class TraceIdTest {
new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'a'};
private static final byte[] secondBytes =
new byte[] {(byte) 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'A'};
private static final TraceId first = TraceId.fromBytes(firstBytes, 0);
private static final TraceId second =
new TraceId(
private static final String first = TraceId.bytesToHex(firstBytes);
private static final String second =
TraceId.fromLongs(
ByteBuffer.wrap(secondBytes).getLong(), ByteBuffer.wrap(secondBytes, 8, 8).getLong());
@Test
void invalidTraceId() {
assertThat(TraceId.getInvalid().getTraceRandomPart()).isEqualTo(0);
assertThat(TraceId.getTraceIdRandomPart(TraceId.getInvalid())).isEqualTo(0);
}
@Test
void isValid() {
assertThat(TraceId.getInvalid().isValid()).isFalse();
assertThat(first.isValid()).isTrue();
assertThat(second.isValid()).isTrue();
assertThat(TraceId.isValid(TraceId.getInvalid())).isFalse();
assertThat(TraceId.isValid(first)).isTrue();
assertThat(TraceId.isValid(second)).isTrue();
assertThat(TraceId.isValid("000000000000004z0000000000000016")).isFalse();
}
@Test
@ -51,8 +52,8 @@ class TraceIdTest {
byte[] id = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00
};
TraceId traceid = TraceId.fromBytes(id, 0);
assertThat(traceid.getTraceRandomPart()).isEqualTo(0x090A0B0C0D0E0F00L);
String traceId = TraceId.bytesToHex(id);
assertThat(TraceId.getTraceIdRandomPart(traceId)).isEqualTo(0x090A0B0C0D0E0F00L);
}
@Test
@ -75,56 +76,32 @@ class TraceIdTest {
0x0F,
0x00
};
TraceId traceid = TraceId.fromBytes(id, 0);
assertThat(traceid.getTraceRandomPart()).isEqualTo(0xFF0A0B0C0D0E0F00L);
String traceId = TraceId.bytesToHex(id);
assertThat(TraceId.getTraceIdRandomPart(traceId)).isEqualTo(0xFF0A0B0C0D0E0F00L);
}
@Test
void fromLowerBase16() {
assertThat(TraceId.fromLowerBase16("00000000000000000000000000000000", 0))
assertThat(TraceId.bytesToHex(TraceId.bytesFromHex("00000000000000000000000000000000", 0)))
.isEqualTo(TraceId.getInvalid());
assertThat(TraceId.fromLowerBase16("00000000000000000000000000000061", 0)).isEqualTo(first);
assertThat(TraceId.fromLowerBase16("ff000000000000000000000000000041", 0)).isEqualTo(second);
assertThat(TraceId.bytesFromHex("00000000000000000000000000000061", 0)).isEqualTo(firstBytes);
assertThat(TraceId.bytesFromHex("ff000000000000000000000000000041", 0)).isEqualTo(secondBytes);
}
@Test
void fromLowerBase16_WithOffset() {
assertThat(TraceId.fromLowerBase16("XX00000000000000000000000000000000CC", 2))
assertThat(TraceId.bytesToHex(TraceId.bytesFromHex("XX00000000000000000000000000000000CC", 2)))
.isEqualTo(TraceId.getInvalid());
assertThat(TraceId.fromLowerBase16("YY00000000000000000000000000000061AA", 2)).isEqualTo(first);
assertThat(TraceId.fromLowerBase16("ZZff000000000000000000000000000041BB", 2))
.isEqualTo(second);
assertThat(TraceId.bytesFromHex("YY00000000000000000000000000000061AA", 2))
.isEqualTo(firstBytes);
assertThat(TraceId.bytesFromHex("ZZff000000000000000000000000000041BB", 2))
.isEqualTo(secondBytes);
}
@Test
void toLowerBase16() {
assertThat(TraceId.getInvalid().toLowerBase16()).isEqualTo("00000000000000000000000000000000");
assertThat(first.toLowerBase16()).isEqualTo("00000000000000000000000000000061");
assertThat(second.toLowerBase16()).isEqualTo("ff000000000000000000000000000041");
}
@Test
void traceId_CompareTo() {
assertThat(first.compareTo(second)).isGreaterThan(0);
assertThat(second.compareTo(first)).isLessThan(0);
assertThat(first.compareTo(TraceId.fromBytes(firstBytes, 0))).isEqualTo(0);
}
@Test
void traceId_EqualsAndHashCode() {
EqualsTester tester = new EqualsTester();
tester.addEqualityGroup(TraceId.getInvalid(), TraceId.getInvalid());
tester.addEqualityGroup(
first, TraceId.fromBytes(Arrays.copyOf(firstBytes, firstBytes.length), 0));
tester.addEqualityGroup(
second, TraceId.fromBytes(Arrays.copyOf(secondBytes, secondBytes.length), 0));
tester.testEquals();
}
@Test
void traceId_ToString() {
assertThat(TraceId.getInvalid().toString()).contains("00000000000000000000000000000000");
assertThat(first.toString()).contains("00000000000000000000000000000061");
assertThat(second.toString()).contains("ff000000000000000000000000000041");
public void toLowerBase16() {
assertThat(TraceId.getInvalid()).isEqualTo("00000000000000000000000000000000");
assertThat(TraceId.bytesToHex(firstBytes)).isEqualTo("00000000000000000000000000000061");
assertThat(TraceId.bytesToHex(secondBytes)).isEqualTo("ff000000000000000000000000000041");
}
}

37
api/src/test/java/io/opentelemetry/trace/propagation/HttpTraceContextTest.java
View File

@ -44,9 +44,7 @@ class HttpTraceContextTest {
private static final TraceState TRACE_STATE_NOT_DEFAULT =
TraceState.builder().set("foo", "bar").set("bar", "baz").build();
private static final String TRACE_ID_BASE16 = "ff000000000000000000000000000041";
private static final TraceId TRACE_ID = TraceId.fromLowerBase16(TRACE_ID_BASE16, 0);
private static final String SPAN_ID_BASE16 = "ff00000000000041";
private static final SpanId SPAN_ID = SpanId.fromLowerBase16(SPAN_ID_BASE16, 0);
private static final byte SAMPLED_TRACE_OPTIONS_BYTES = 1;
private static final TraceFlags SAMPLED_TRACE_OPTIONS =
TraceFlags.fromByte(SAMPLED_TRACE_OPTIONS_BYTES);
@ -82,7 +80,8 @@ class HttpTraceContextTest {
final Map<String, String> carrier = new LinkedHashMap<>();
Context context =
withSpanContext(
SpanContext.create(TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT),
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT),
Context.current());
httpTraceContext.inject(
context,
@ -112,7 +111,8 @@ class HttpTraceContextTest {
Map<String, String> carrier = new LinkedHashMap<>();
Context context =
withSpanContext(
SpanContext.create(TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT),
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT),
Context.current());
httpTraceContext.inject(context, carrier, setter);
assertThat(carrier).containsExactly(entry(TRACE_PARENT, TRACEPARENT_HEADER_SAMPLED));
@ -123,7 +123,8 @@ class HttpTraceContextTest {
Map<String, String> carrier = new LinkedHashMap<>();
Context context =
withSpanContext(
SpanContext.create(TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT),
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getDefault(), TRACE_STATE_DEFAULT),
Context.current());
httpTraceContext.inject(context, carrier, setter);
assertThat(carrier).containsExactly(entry(TRACE_PARENT, TRACEPARENT_HEADER_NOT_SAMPLED));
@ -134,7 +135,8 @@ class HttpTraceContextTest {
Map<String, String> carrier = new LinkedHashMap<>();
Context context =
withSpanContext(
SpanContext.create(TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_NOT_DEFAULT),
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_OPTIONS, TRACE_STATE_NOT_DEFAULT),
Context.current());
httpTraceContext.inject(context, carrier, setter);
assertThat(carrier)
@ -148,7 +150,8 @@ class HttpTraceContextTest {
Map<String, String> carrier = new LinkedHashMap<>();
Context context =
withSpanContext(
SpanContext.create(TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_NOT_DEFAULT),
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getDefault(), TRACE_STATE_NOT_DEFAULT),
Context.current());
httpTraceContext.inject(context, carrier, setter);
assertThat(carrier)
@ -173,7 +176,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
@ -183,7 +186,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
}
@Test
@ -194,7 +197,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_NOT_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_OPTIONS, TRACE_STATE_NOT_DEFAULT));
}
@Test
@ -205,7 +208,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_NOT_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getDefault(), TRACE_STATE_NOT_DEFAULT));
}
@Test
@ -215,7 +218,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
}
@Test
@ -226,7 +229,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
}
@Test
@ -237,7 +240,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_NOT_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getDefault(), TRACE_STATE_NOT_DEFAULT));
}
@Test
@ -305,7 +308,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), invalidHeaders, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
@ -316,7 +319,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), invalidHeaders, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
@ -327,7 +330,7 @@ class HttpTraceContextTest {
assertThat(getSpanContext(httpTraceContext.extract(Context.current(), invalidHeaders, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test

7
exporters/jaeger/src/main/java/io/opentelemetry/exporters/jaeger/Adapter.java
View File

@ -28,6 +28,7 @@ import io.opentelemetry.sdk.extensions.otproto.TraceProtoUtils;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.sdk.trace.data.SpanData.Event;
import io.opentelemetry.sdk.trace.data.SpanData.Link;
import io.opentelemetry.trace.SpanId;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
@ -85,7 +86,7 @@ final class Adapter {
target.addAllReferences(toSpanRefs(span.getLinks()));
// add the parent span
if (span.getParentSpanId().isValid()) {
if (SpanId.isValid(span.getParentSpanId())) {
target.addReferences(
Model.SpanRef.newBuilder()
.setTraceId(TraceProtoUtils.toProtoTraceId(span.getTraceId()))
@ -280,8 +281,8 @@ final class Adapter {
@VisibleForTesting
static Model.SpanRef toSpanRef(Link link) {
Model.SpanRef.Builder builder = Model.SpanRef.newBuilder();
builder.setTraceId(TraceProtoUtils.toProtoTraceId(link.getContext().getTraceId()));
builder.setSpanId(TraceProtoUtils.toProtoSpanId(link.getContext().getSpanId()));
builder.setTraceId(TraceProtoUtils.toProtoTraceId(link.getContext().getTraceIdAsHexString()));
builder.setSpanId(TraceProtoUtils.toProtoSpanId(link.getContext().getSpanIdAsHexString()));
// we can assume that all links are *follows from*
// https://github.com/open-telemetry/opentelemetry-java/issues/475

43
exporters/jaeger/src/test/java/io/opentelemetry/exporters/jaeger/AdapterTest.java
View File

@ -34,10 +34,8 @@ import io.opentelemetry.sdk.trace.data.SpanData.Event;
import io.opentelemetry.sdk.trace.data.SpanData.Link;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
import java.util.Collection;
import java.util.Collections;
@ -226,10 +224,8 @@ class AdapterTest {
Model.SpanRef spanRef = Adapter.toSpanRef(link);
// verify
assertEquals(
TraceProtoUtils.toProtoSpanId(SpanId.fromLowerBase16(SPAN_ID, 0)), spanRef.getSpanId());
assertEquals(
TraceProtoUtils.toProtoTraceId(TraceId.fromLowerBase16(TRACE_ID, 0)), spanRef.getTraceId());
assertEquals(TraceProtoUtils.toProtoSpanId(SPAN_ID), spanRef.getSpanId());
assertEquals(TraceProtoUtils.toProtoTraceId(TRACE_ID), spanRef.getTraceId());
assertEquals(Model.SpanRefType.FOLLOWS_FROM, spanRef.getRefType());
}
@ -240,8 +236,8 @@ class AdapterTest {
SpanData span =
TestSpanData.newBuilder()
.setHasEnded(true)
.setTraceId(TraceId.fromLowerBase16(TRACE_ID, 0))
.setSpanId(SpanId.fromLowerBase16(SPAN_ID, 0))
.setTraceId(TRACE_ID)
.setSpanId(SPAN_ID)
.setName("GET /api/endpoint")
.setStartEpochNanos(TimeUnit.MILLISECONDS.toNanos(startMs))
.setEndEpochNanos(TimeUnit.MILLISECONDS.toNanos(endMs))
@ -267,8 +263,8 @@ class AdapterTest {
SpanData span =
TestSpanData.newBuilder()
.setHasEnded(true)
.setTraceId(TraceId.fromLowerBase16(TRACE_ID, 0))
.setSpanId(SpanId.fromLowerBase16(SPAN_ID, 0))
.setTraceId(TRACE_ID)
.setSpanId(SPAN_ID)
.setName("GET /api/endpoint")
.setStartEpochNanos(TimeUnit.MILLISECONDS.toNanos(startMs))
.setEndEpochNanos(TimeUnit.MILLISECONDS.toNanos(endMs))
@ -303,9 +299,9 @@ class AdapterTest {
return TestSpanData.newBuilder()
.setHasEnded(true)
.setTraceId(TraceId.fromLowerBase16(TRACE_ID, 0))
.setSpanId(SpanId.fromLowerBase16(SPAN_ID, 0))
.setParentSpanId(SpanId.fromLowerBase16(PARENT_SPAN_ID, 0))
.setTraceId(TRACE_ID)
.setSpanId(SPAN_ID)
.setParentSpanId(PARENT_SPAN_ID)
.setName("GET /api/endpoint")
.setStartEpochNanos(TimeUnit.MILLISECONDS.toNanos(startMs))
.setEndEpochNanos(TimeUnit.MILLISECONDS.toNanos(endMs))
@ -322,10 +318,7 @@ class AdapterTest {
private static SpanContext createSpanContext(String traceId, String spanId) {
return SpanContext.create(
TraceId.fromLowerBase16(traceId, 0),
SpanId.fromLowerBase16(spanId, 0),
TraceFlags.builder().build(),
TraceState.builder().build());
traceId, spanId, TraceFlags.builder().build(), TraceState.builder().build());
}
@Nullable
@ -342,12 +335,8 @@ class AdapterTest {
boolean found = false;
for (Model.SpanRef spanRef : jaegerSpan.getReferencesList()) {
if (Model.SpanRefType.FOLLOWS_FROM.equals(spanRef.getRefType())) {
assertEquals(
TraceProtoUtils.toProtoTraceId(TraceId.fromLowerBase16(LINK_TRACE_ID, 0)),
spanRef.getTraceId());
assertEquals(
TraceProtoUtils.toProtoSpanId(SpanId.fromLowerBase16(LINK_SPAN_ID, 0)),
spanRef.getSpanId());
assertEquals(TraceProtoUtils.toProtoTraceId(LINK_TRACE_ID), spanRef.getTraceId());
assertEquals(TraceProtoUtils.toProtoSpanId(LINK_SPAN_ID), spanRef.getSpanId());
found = true;
}
}
@ -358,12 +347,8 @@ class AdapterTest {
boolean found = false;
for (Model.SpanRef spanRef : jaegerSpan.getReferencesList()) {
if (Model.SpanRefType.CHILD_OF.equals(spanRef.getRefType())) {
assertEquals(
TraceProtoUtils.toProtoTraceId(TraceId.fromLowerBase16(TRACE_ID, 0)),
spanRef.getTraceId());
assertEquals(
TraceProtoUtils.toProtoSpanId(SpanId.fromLowerBase16(PARENT_SPAN_ID, 0)),
spanRef.getSpanId());
assertEquals(TraceProtoUtils.toProtoTraceId(TRACE_ID), spanRef.getTraceId());
assertEquals(TraceProtoUtils.toProtoSpanId(PARENT_SPAN_ID), spanRef.getSpanId());
found = true;
}
}

14
exporters/jaeger/src/test/java/io/opentelemetry/exporters/jaeger/JaegerGrpcSpanExporterTest.java
View File

@ -40,9 +40,7 @@ import io.opentelemetry.sdk.extensions.otproto.TraceProtoUtils;
import io.opentelemetry.sdk.trace.TestSpanData;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.TraceId;
import java.net.InetAddress;
import java.util.Collections;
import java.util.HashMap;
@ -94,8 +92,8 @@ class JaegerGrpcSpanExporterTest {
SpanData span =
TestSpanData.newBuilder()
.setHasEnded(true)
.setTraceId(TraceId.fromLowerBase16(TRACE_ID, 0))
.setSpanId(SpanId.fromLowerBase16(SPAN_ID, 0))
.setTraceId(TRACE_ID)
.setSpanId(SPAN_ID)
.setName("GET /api/endpoint")
.setStartEpochNanos(TimeUnit.MILLISECONDS.toNanos(startMs))
.setEndEpochNanos(TimeUnit.MILLISECONDS.toNanos(endMs))
@ -119,12 +117,8 @@ class JaegerGrpcSpanExporterTest {
Model.Batch batch = requestCaptor.getValue().getBatch();
assertEquals(1, batch.getSpansCount());
assertEquals("GET /api/endpoint", batch.getSpans(0).getOperationName());
assertEquals(
TraceProtoUtils.toProtoTraceId(TraceId.fromLowerBase16(TRACE_ID, 0)),
batch.getSpans(0).getTraceId());
assertEquals(
TraceProtoUtils.toProtoSpanId(SpanId.fromLowerBase16(SPAN_ID, 0)),
batch.getSpans(0).getSpanId());
assertEquals(TraceProtoUtils.toProtoTraceId(TRACE_ID), batch.getSpans(0).getTraceId());
assertEquals(TraceProtoUtils.toProtoSpanId(SPAN_ID), batch.getSpans(0).getSpanId());
assertEquals("test", batch.getProcess().getServiceName());
assertEquals(3, batch.getProcess().getTagsCount());

4
exporters/logging/src/test/java/io/opentelemetry/exporters/logging/LoggingSpanExporterTest.java
View File

@ -60,8 +60,8 @@ class LoggingSpanExporterTest {
SpanData spanData =
TestSpanData.newBuilder()
.setHasEnded(true)
.setTraceId(new TraceId(1234L, 6789L))
.setSpanId(new SpanId(9876L))
.setTraceId(TraceId.fromLongs(1234L, 6789L))
.setSpanId(SpanId.fromLong(9876L))
.setStartEpochNanos(epochNanos)
.setEndEpochNanos(epochNanos + 1000)
.setStatus(Status.OK)

7
exporters/otlp/src/main/java/io/opentelemetry/exporters/otlp/SpanAdapter.java
View File

@ -38,6 +38,7 @@ import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.sdk.trace.data.SpanData.Event;
import io.opentelemetry.sdk.trace.data.SpanData.Link;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanId;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
@ -97,7 +98,7 @@ final class SpanAdapter {
builder.setTraceId(TraceProtoUtils.toProtoTraceId(spanData.getTraceId()));
builder.setSpanId(TraceProtoUtils.toProtoSpanId(spanData.getSpanId()));
// TODO: Set TraceState;
if (spanData.getParentSpanId().isValid()) {
if (SpanId.isValid(spanData.getParentSpanId())) {
builder.setParentSpanId(TraceProtoUtils.toProtoSpanId(spanData.getParentSpanId()));
}
builder.setName(spanData.getName());
@ -163,8 +164,8 @@ final class SpanAdapter {
static Span.Link toProtoSpanLink(Link link) {
final Span.Link.Builder builder = Span.Link.newBuilder();
builder.setTraceId(TraceProtoUtils.toProtoTraceId(link.getContext().getTraceId()));
builder.setSpanId(TraceProtoUtils.toProtoSpanId(link.getContext().getSpanId()));
builder.setTraceId(TraceProtoUtils.toProtoTraceId(link.getContext().getTraceIdAsHexString()));
builder.setSpanId(TraceProtoUtils.toProtoSpanId(link.getContext().getSpanIdAsHexString()));
// TODO: Set TraceState;
Attributes attributes = link.getAttributes();
attributes.forEach(

6
exporters/otlp/src/test/java/io/opentelemetry/exporters/otlp/OtlpGrpcSpanExporterTest.java
View File

@ -33,9 +33,7 @@ import io.opentelemetry.proto.trace.v1.ResourceSpans;
import io.opentelemetry.sdk.trace.TestSpanData;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.TraceId;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
@ -256,8 +254,8 @@ class OtlpGrpcSpanExporterTest {
long endNs = startNs + duration;
return TestSpanData.newBuilder()
.setHasEnded(true)
.setTraceId(TraceId.fromLowerBase16(TRACE_ID, 0))
.setSpanId(SpanId.fromLowerBase16(SPAN_ID, 0))
.setTraceId(TRACE_ID)
.setSpanId(SPAN_ID)
.setName("GET /api/endpoint")
.setStartEpochNanos(startNs)
.setEndEpochNanos(endNs)

5
exporters/otlp/src/test/java/io/opentelemetry/exporters/otlp/SpanAdapterTest.java
View File

@ -63,9 +63,10 @@ import org.junit.jupiter.api.Test;
class SpanAdapterTest {
private static final byte[] TRACE_ID_BYTES =
new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4};
private static final TraceId TRACE_ID = TraceId.fromBytes(TRACE_ID_BYTES, 0);
private static final String TRACE_ID = TraceId.bytesToHex(TRACE_ID_BYTES);
private static final byte[] SPAN_ID_BYTES = new byte[] {0, 0, 0, 0, 4, 3, 2, 1};
private static final SpanId SPAN_ID = SpanId.fromBytes(SPAN_ID_BYTES, 0);
private static final String SPAN_ID = SpanId.bytesToHex(SPAN_ID_BYTES);
private static final TraceState TRACE_STATE = TraceState.builder().build();
private static final SpanContext SPAN_CONTEXT =
SpanContext.create(

9
exporters/zipkin/src/main/java/io/opentelemetry/exporters/zipkin/ZipkinSpanExporter.java
View File

@ -29,6 +29,7 @@ import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.sdk.trace.data.SpanData.Event;
import io.opentelemetry.sdk.trace.export.SpanExporter;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.attributes.SemanticAttributes;
import java.io.IOException;
@ -133,16 +134,16 @@ public final class ZipkinSpanExporter implements SpanExporter {
final Span.Builder spanBuilder =
Span.newBuilder()
.traceId(spanData.getTraceId().toLowerBase16())
.id(spanData.getSpanId().toLowerBase16())
.traceId(spanData.getTraceId())
.id(spanData.getSpanId())
.kind(toSpanKind(spanData))
.name(spanData.getName())
.timestamp(toEpochMicros(spanData.getStartEpochNanos()))
.duration(endTimestamp - startTimestamp)
.localEndpoint(endpoint);
if (spanData.getParentSpanId().isValid()) {
spanBuilder.parentId(spanData.getParentSpanId().toLowerBase16());
if (SpanId.isValid(spanData.getParentSpanId())) {
spanBuilder.parentId(spanData.getParentSpanId());
}
ReadableAttributes spanAttributes = spanData.getAttributes();

8
exporters/zipkin/src/test/java/io/opentelemetry/exporters/zipkin/ZipkinSpanExporterEndToEndHttpTest.java
View File

@ -26,10 +26,8 @@ import io.opentelemetry.sdk.trace.data.EventImpl;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.sdk.trace.data.SpanData.Event;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
@ -153,9 +151,9 @@ public class ZipkinSpanExporterEndToEndHttpTest {
private static TestSpanData.Builder buildStandardSpan() {
return TestSpanData.newBuilder()
.setTraceId(TraceId.fromLowerBase16(TRACE_ID, 0))
.setSpanId(SpanId.fromLowerBase16(SPAN_ID, 0))
.setParentSpanId(SpanId.fromLowerBase16(PARENT_SPAN_ID, 0))
.setTraceId(TRACE_ID)
.setSpanId(SPAN_ID)
.setParentSpanId(PARENT_SPAN_ID)
.setTraceFlags(TraceFlags.builder().setIsSampled(true).build())
.setStatus(Status.OK)
.setKind(Kind.SERVER)

8
exporters/zipkin/src/test/java/io/opentelemetry/exporters/zipkin/ZipkinSpanExporterTest.java
View File

@ -36,10 +36,8 @@ import io.opentelemetry.sdk.trace.data.EventImpl;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.sdk.trace.data.SpanData.Event;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.attributes.SemanticAttributes;
import java.io.IOException;
import java.util.Collections;
@ -311,9 +309,9 @@ class ZipkinSpanExporterTest {
private static TestSpanData.Builder buildStandardSpan() {
return TestSpanData.newBuilder()
.setTraceId(TraceId.fromLowerBase16(TRACE_ID, 0))
.setSpanId(SpanId.fromLowerBase16(SPAN_ID, 0))
.setParentSpanId(SpanId.fromLowerBase16(PARENT_SPAN_ID, 0))
.setTraceId(TRACE_ID)
.setSpanId(SPAN_ID)
.setParentSpanId(PARENT_SPAN_ID)
.setTraceFlags(TraceFlags.builder().setIsSampled(true).build())
.setStatus(Status.OK)
.setKind(Kind.SERVER)

8
extensions/trace_propagators/src/jmh/java/io/opentelemetry/extensions/trace/propagation/PropagatorContextInjectBenchmark.java
View File

@ -20,9 +20,7 @@ import io.grpc.Context;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.trace.DefaultSpan;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
import io.opentelemetry.trace.TracingContextUtils;
import java.util.Arrays;
@ -92,11 +90,7 @@ public class PropagatorContextInjectBenchmark {
byte sampledTraceOptionsBytes = 1;
TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes);
TraceState traceStateDefault = TraceState.builder().build();
return SpanContext.create(
TraceId.fromLowerBase16(traceId, 0),
SpanId.fromLowerBase16(spanId, 0),
sampledTraceOptions,
traceStateDefault);
return SpanContext.create(traceId, spanId, sampledTraceOptions, traceStateDefault);
}
}

31
extensions/trace_propagators/src/main/java/io/opentelemetry/extensions/trace/propagation/AwsXRayPropagator.java
View File

@ -93,14 +93,14 @@ public class AwsXRayPropagator implements TextMapPropagator {
SpanContext spanContext = span.getContext();
String otTraceId = spanContext.getTraceId().toLowerBase16();
String otTraceId = spanContext.getTraceIdAsHexString();
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().toLowerBase16();
String parentId = spanContext.getSpanIdAsHexString();
char samplingFlag = spanContext.getTraceFlags().isSampled() ? IS_SAMPLED : NOT_SAMPLED;
// TODO: Add OT trace state to the X-Ray trace header
@ -138,8 +138,8 @@ public class AwsXRayPropagator implements TextMapPropagator {
return SpanContext.getInvalid();
}
TraceId traceId = TraceId.getInvalid();
SpanId spanId = SpanId.getInvalid();
String traceId = TraceId.getInvalid();
String spanId = SpanId.getInvalid();
TraceFlags traceFlags = TraceFlags.getDefault();
int pos = 0;
@ -175,8 +175,7 @@ public class AwsXRayPropagator implements TextMapPropagator {
}
// TODO: Put the arbitrary TraceHeader keys in OT trace state
}
if (!traceId.isValid()) {
if (!TraceId.isValid(traceId)) {
logger.fine(
"Invalid TraceId in X-Ray trace header: '"
+ TRACE_HEADER_KEY
@ -186,7 +185,7 @@ public class AwsXRayPropagator implements TextMapPropagator {
return SpanContext.getInvalid();
}
if (!spanId.isValid()) {
if (!SpanId.isValid(spanId)) {
logger.fine(
"Invalid ParentId in X-Ray trace header: '"
+ TRACE_HEADER_KEY
@ -209,7 +208,7 @@ public class AwsXRayPropagator implements TextMapPropagator {
return SpanContext.createFromRemoteParent(traceId, spanId, traceFlags, TraceState.getDefault());
}
private static TraceId parseTraceId(String xrayTraceId) {
private static String parseTraceId(String xrayTraceId) {
if (xrayTraceId.length() != TRACE_ID_LENGTH) {
return TraceId.getInvalid();
}
@ -229,24 +228,16 @@ public class AwsXRayPropagator implements TextMapPropagator {
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);
try {
// X-Ray trace id format is 1-{8 digit hex}-{24 digit hex}
return TraceId.fromLowerBase16(epochPart + uniquePart, 0);
} catch (Exception e) {
return TraceId.getInvalid();
}
// X-Ray trace id format is 1-{8 digit hex}-{24 digit hex}
return epochPart + uniquePart;
}
private static SpanId parseSpanId(String xrayParentId) {
private static String parseSpanId(String xrayParentId) {
if (xrayParentId.length() != PARENT_ID_LENGTH) {
return SpanId.getInvalid();
}
try {
return SpanId.fromLowerBase16(xrayParentId, 0);
} catch (Exception e) {
return SpanId.getInvalid();
}
return xrayParentId;
}
@Nullable

4
extensions/trace_propagators/src/main/java/io/opentelemetry/extensions/trace/propagation/B3PropagatorInjectorMultipleHeaders.java
View File

@ -39,8 +39,8 @@ final class B3PropagatorInjectorMultipleHeaders implements B3PropagatorInjector
SpanContext spanContext = span.getContext();
String sampled = spanContext.getTraceFlags().isSampled() ? Common.TRUE_INT : Common.FALSE_INT;
setter.set(carrier, B3Propagator.TRACE_ID_HEADER, spanContext.getTraceId().toLowerBase16());
setter.set(carrier, B3Propagator.SPAN_ID_HEADER, spanContext.getSpanId().toLowerBase16());
setter.set(carrier, B3Propagator.TRACE_ID_HEADER, spanContext.getTraceIdAsHexString());
setter.set(carrier, B3Propagator.SPAN_ID_HEADER, spanContext.getSpanIdAsHexString());
setter.set(carrier, B3Propagator.SAMPLED_HEADER, sampled);
}
}

12
extensions/trace_propagators/src/main/java/io/opentelemetry/extensions/trace/propagation/B3PropagatorInjectorSingleHeader.java
View File

@ -29,8 +29,8 @@ import javax.annotation.concurrent.Immutable;
@Immutable
final class B3PropagatorInjectorSingleHeader implements B3PropagatorInjector {
private static final int SAMPLED_FLAG_SIZE = 1;
private static final int TRACE_ID_HEX_SIZE = 2 * TraceId.getSize();
private static final int SPAN_ID_HEX_SIZE = 2 * SpanId.getSize();
private static final int TRACE_ID_HEX_SIZE = TraceId.getHexLength();
private static final int SPAN_ID_HEX_SIZE = SpanId.getHexLength();
private static final int COMBINED_HEADER_DELIMITER_SIZE = 1;
private static final int SPAN_ID_OFFSET = TRACE_ID_HEX_SIZE + COMBINED_HEADER_DELIMITER_SIZE;
private static final int SAMPLED_FLAG_OFFSET =
@ -50,9 +50,13 @@ final class B3PropagatorInjectorSingleHeader implements B3PropagatorInjector {
SpanContext spanContext = span.getContext();
char[] chars = new char[COMBINED_HEADER_SIZE];
spanContext.getTraceId().copyLowerBase16To(chars, 0);
String traceId = spanContext.getTraceIdAsHexString();
traceId.getChars(0, traceId.length(), chars, 0);
chars[SPAN_ID_OFFSET - 1] = B3Propagator.COMBINED_HEADER_DELIMITER_CHAR;
spanContext.getSpanId().copyLowerBase16To(chars, SPAN_ID_OFFSET);
String spanId = spanContext.getSpanIdAsHexString();
System.arraycopy(spanId.toCharArray(), 0, chars, SPAN_ID_OFFSET, SpanId.getHexLength());
chars[SAMPLED_FLAG_OFFSET - 1] = B3Propagator.COMBINED_HEADER_DELIMITER_CHAR;
chars[SAMPLED_FLAG_OFFSET] =
spanContext.getTraceFlags().isSampled()

23
extensions/trace_propagators/src/main/java/io/opentelemetry/extensions/trace/propagation/Common.java
View File

@ -35,8 +35,8 @@ final class Common {
static final String TRUE_INT = "1";
static final String FALSE_INT = "0";
static final int MAX_TRACE_ID_LENGTH = 2 * TraceId.getSize();
static final int MAX_SPAN_ID_LENGTH = 2 * SpanId.getSize();
static final int MAX_TRACE_ID_LENGTH = TraceId.getHexLength();
static final int MAX_SPAN_ID_LENGTH = SpanId.getHexLength();
static final int MIN_TRACE_ID_LENGTH = TraceId.getSize();
private static final TraceFlags SAMPLED_FLAGS = TraceFlags.builder().setIsSampled(true).build();
private static final TraceFlags NOT_SAMPLED_FLAGS =
@ -52,8 +52,8 @@ final class Common {
: NOT_SAMPLED_FLAGS;
return SpanContext.createFromRemoteParent(
TraceId.fromLowerBase16(StringUtils.padLeft(traceId, MAX_TRACE_ID_LENGTH), 0),
SpanId.fromLowerBase16(spanId, 0),
StringUtils.padLeft(traceId, MAX_TRACE_ID_LENGTH),
spanId,
traceFlags,
TraceState.getDefault());
} catch (Exception e) {
@ -62,24 +62,13 @@ final class Common {
}
}
private static boolean isHex(String value) {
for (int i = 0; i < value.length(); i++) {
if (Character.digit(value.charAt(i), 16) == -1) {
return false;
}
}
return true;
}
static boolean isTraceIdValid(String value) {
return !(StringUtils.isNullOrEmpty(value)
|| (value.length() != MIN_TRACE_ID_LENGTH && value.length() != MAX_TRACE_ID_LENGTH)
|| !isHex(value));
|| !TraceId.isValid(StringUtils.padLeft(value, TraceId.getHexLength())));
}
static boolean isSpanIdValid(String value) {
return !(StringUtils.isNullOrEmpty(value)
|| value.length() != MAX_SPAN_ID_LENGTH
|| !isHex(value));
return !StringUtils.isNullOrEmpty(value) && SpanId.isValid(value);
}
}

31
extensions/trace_propagators/src/main/java/io/opentelemetry/extensions/trace/propagation/JaegerPropagator.java
View File

@ -50,16 +50,16 @@ public class JaegerPropagator implements TextMapPropagator {
static final char DEPRECATED_PARENT_SPAN = '0';
static final char PROPAGATION_HEADER_DELIMITER = ':';
private static final int MAX_TRACE_ID_LENGTH = 2 * TraceId.getSize();
private static final int MAX_SPAN_ID_LENGTH = 2 * SpanId.getSize();
private static final int MAX_TRACE_ID_LENGTH = TraceId.getHexLength();
private static final int MAX_SPAN_ID_LENGTH = SpanId.getHexLength();
private static final int MAX_FLAGS_LENGTH = 2;
private static final char IS_SAMPLED = '1';
private static final char NOT_SAMPLED = '0';
private static final int PROPAGATION_HEADER_DELIMITER_SIZE = 1;
private static final int TRACE_ID_HEX_SIZE = 2 * TraceId.getSize();
private static final int SPAN_ID_HEX_SIZE = 2 * SpanId.getSize();
private static final int TRACE_ID_HEX_SIZE = TraceId.getHexLength();
private static final int SPAN_ID_HEX_SIZE = SpanId.getHexLength();
private static final int PARENT_SPAN_ID_SIZE = 1;
private static final int SAMPLED_FLAG_SIZE = 1;
@ -94,9 +94,18 @@ public class JaegerPropagator implements TextMapPropagator {
SpanContext spanContext = span.getContext();
char[] chars = new char[PROPAGATION_HEADER_SIZE];
spanContext.getTraceId().copyLowerBase16To(chars, 0);
String traceId = spanContext.getTraceIdAsHexString();
for (int i = 0; i < traceId.length(); i++) {
chars[i] = traceId.charAt(i);
}
chars[SPAN_ID_OFFSET - 1] = PROPAGATION_HEADER_DELIMITER;
spanContext.getSpanId().copyLowerBase16To(chars, SPAN_ID_OFFSET);
String spanId = spanContext.getSpanIdAsHexString();
for (int i = 0; i < spanId.length(); i++) {
chars[SPAN_ID_OFFSET + i] = spanId.charAt(i);
}
chars[PARENT_SPAN_ID_OFFSET - 1] = PROPAGATION_HEADER_DELIMITER;
chars[PARENT_SPAN_ID_OFFSET] = DEPRECATED_PARENT_SPAN;
chars[SAMPLED_FLAG_OFFSET - 1] = PROPAGATION_HEADER_DELIMITER;
@ -189,11 +198,13 @@ public class JaegerPropagator implements TextMapPropagator {
int flagsInt = Integer.parseInt(flags);
TraceFlags traceFlags = ((flagsInt & 1) == 1) ? SAMPLED_FLAGS : NOT_SAMPLED_FLAGS;
String otelTraceId = StringUtils.padLeft(traceId, MAX_TRACE_ID_LENGTH);
String otelSpanId = StringUtils.padLeft(spanId, MAX_SPAN_ID_LENGTH);
if (!TraceId.isValid(otelTraceId) || !SpanId.isValid(otelSpanId)) {
return SpanContext.getInvalid();
}
return SpanContext.createFromRemoteParent(
TraceId.fromLowerBase16(StringUtils.padLeft(traceId, MAX_TRACE_ID_LENGTH), 0),
SpanId.fromLowerBase16(StringUtils.padLeft(spanId, MAX_SPAN_ID_LENGTH), 0),
traceFlags,
TraceState.getDefault());
otelTraceId, otelSpanId, traceFlags, TraceState.getDefault());
} catch (Exception e) {
logger.log(
Level.FINE,

13
extensions/trace_propagators/src/main/java/io/opentelemetry/extensions/trace/propagation/OtTracerPropagator.java
View File

@ -16,11 +16,14 @@
package io.opentelemetry.extensions.trace.propagation;
import static io.opentelemetry.extensions.trace.propagation.Common.MAX_TRACE_ID_LENGTH;
import io.grpc.Context;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.trace.DefaultSpan;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TracingContextUtils;
import java.util.Arrays;
import java.util.Collections;
@ -71,8 +74,8 @@ public class OtTracerPropagator implements TextMapPropagator {
if (!spanContext.isValid()) {
return;
}
setter.set(carrier, TRACE_ID_HEADER, spanContext.getTraceId().toLowerBase16());
setter.set(carrier, SPAN_ID_HEADER, spanContext.getSpanId().toLowerBase16());
setter.set(carrier, TRACE_ID_HEADER, spanContext.getTraceIdAsHexString());
setter.set(carrier, SPAN_ID_HEADER, spanContext.getSpanIdAsHexString());
setter.set(carrier, SAMPLED_HEADER, String.valueOf(spanContext.getTraceFlags().isSampled()));
}
@ -81,7 +84,11 @@ public class OtTracerPropagator implements TextMapPropagator {
if (context == null || getter == null) {
return context;
}
String traceId = getter.get(carrier, TRACE_ID_HEADER);
String incomingTraceId = getter.get(carrier, TRACE_ID_HEADER);
String traceId =
incomingTraceId == null
? TraceId.getInvalid()
: StringUtils.padLeft(incomingTraceId, MAX_TRACE_ID_LENGTH);
String spanId = getter.get(carrier, SPAN_ID_HEADER);
String sampled = getter.get(carrier, SAMPLED_HEADER);
SpanContext spanContext = buildSpanContext(traceId, spanId, sampled);

22
extensions/trace_propagators/src/test/java/io/opentelemetry/extensions/trace/propagation/AwsXRayPropagatorTest.java
View File

@ -23,9 +23,7 @@ import io.grpc.Context;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.trace.DefaultSpan;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
import io.opentelemetry.trace.TracingContextUtils;
import java.util.Collections;
@ -37,11 +35,9 @@ import org.junit.jupiter.api.Test;
class AwsXRayPropagatorTest {
private static final String TRACE_ID_BASE16 = "8a3c60f7d188f8fa79d48a391a778fa6";
private static final TraceId TRACE_ID = TraceId.fromLowerBase16(TRACE_ID_BASE16, 0);
private static final TraceState TRACE_STATE_DEFAULT = TraceState.getDefault();
private static final String SPAN_ID_BASE16 = "53995c3f42cd8ad8";
private static final SpanId SPAN_ID = SpanId.fromLowerBase16(SPAN_ID_BASE16, 0);
private static final TraceFlags SAMPLED_TRACE_FLAG =
TraceFlags.builder().setIsSampled(true).build();
@ -61,7 +57,8 @@ class AwsXRayPropagatorTest {
Map<String, String> carrier = new LinkedHashMap<>();
xrayPropagator.inject(
withSpanContext(
SpanContext.create(TRACE_ID, SPAN_ID, SAMPLED_TRACE_FLAG, TRACE_STATE_DEFAULT),
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_FLAG, TRACE_STATE_DEFAULT),
Context.current()),
carrier,
setter);
@ -77,7 +74,8 @@ class AwsXRayPropagatorTest {
Map<String, String> carrier = new LinkedHashMap<>();
xrayPropagator.inject(
withSpanContext(
SpanContext.create(TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT),
SpanContext.create(
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getDefault(), TRACE_STATE_DEFAULT),
Context.current()),
carrier,
setter);
@ -94,8 +92,8 @@ class AwsXRayPropagatorTest {
xrayPropagator.inject(
withSpanContext(
SpanContext.create(
TRACE_ID,
SPAN_ID,
TRACE_ID_BASE16,
SPAN_ID_BASE16,
TraceFlags.getDefault(),
TraceState.builder().set("foo", "bar").build()),
Context.current()),
@ -128,7 +126,7 @@ class AwsXRayPropagatorTest {
assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, SAMPLED_TRACE_FLAG, TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_FLAG, TRACE_STATE_DEFAULT));
}
@Test
@ -141,7 +139,7 @@ class AwsXRayPropagatorTest {
assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
}
@Test
@ -154,7 +152,7 @@ class AwsXRayPropagatorTest {
assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, SAMPLED_TRACE_FLAG, TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_FLAG, TRACE_STATE_DEFAULT));
}
@Test
@ -168,7 +166,7 @@ class AwsXRayPropagatorTest {
assertThat(getSpanContext(xrayPropagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
TRACE_ID, SPAN_ID, SAMPLED_TRACE_FLAG, TRACE_STATE_DEFAULT));
TRACE_ID_BASE16, SPAN_ID_BASE16, SAMPLED_TRACE_FLAG, TRACE_STATE_DEFAULT));
}
@Test

143
extensions/trace_propagators/src/test/java/io/opentelemetry/extensions/trace/propagation/B3PropagatorTest.java
View File

@ -39,15 +39,12 @@ import org.junit.jupiter.api.Test;
class B3PropagatorTest {
private static final TraceState TRACE_STATE_DEFAULT = TraceState.builder().build();
private static final String TRACE_ID_BASE16 = "ff000000000000000000000000000041";
private static final String TRACE_ID = "ff000000000000000000000000000041";
private static final String TRACE_ID_ALL_ZERO = "00000000000000000000000000000000";
private static final TraceId TRACE_ID = TraceId.fromLowerBase16(TRACE_ID_BASE16, 0);
private static final String SHORT_TRACE_ID_BASE16 = "ff00000000000000";
private static final TraceId SHORT_TRACE_ID =
TraceId.fromLowerBase16(StringUtils.padLeft(SHORT_TRACE_ID_BASE16, 32), 0);
private static final String SPAN_ID_BASE16 = "ff00000000000041";
private static final String SHORT_TRACE_ID = "ff00000000000000";
private static final String SHORT_TRACE_ID_FULL = StringUtils.padLeft(SHORT_TRACE_ID, 32);
private static final String SPAN_ID = "ff00000000000041";
private static final String SPAN_ID_ALL_ZERO = "0000000000000000";
private static final SpanId SPAN_ID = SpanId.fromLowerBase16(SPAN_ID_BASE16, 0);
private static final byte SAMPLED_TRACE_OPTIONS_BYTES = 1;
private static final TraceFlags SAMPLED_TRACE_OPTIONS =
TraceFlags.fromByte(SAMPLED_TRACE_OPTIONS_BYTES);
@ -96,8 +93,8 @@ class B3PropagatorTest {
Context.current()),
carrier,
setter);
assertThat(carrier).containsEntry(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
assertThat(carrier).containsEntry(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
assertThat(carrier).containsEntry(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
assertThat(carrier).containsEntry(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
assertThat(carrier).containsEntry(B3Propagator.SAMPLED_HEADER, "1");
}
@ -110,8 +107,8 @@ class B3PropagatorTest {
Context.current()),
null,
(Setter<Map<String, String>>) (ignored, key, value) -> carrier.put(key, value));
assertThat(carrier).containsEntry(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
assertThat(carrier).containsEntry(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
assertThat(carrier).containsEntry(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
assertThat(carrier).containsEntry(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
assertThat(carrier).containsEntry(B3Propagator.SAMPLED_HEADER, "1");
}
@ -124,8 +121,8 @@ class B3PropagatorTest {
Context.current()),
carrier,
setter);
assertThat(carrier).containsEntry(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
assertThat(carrier).containsEntry(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
assertThat(carrier).containsEntry(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
assertThat(carrier).containsEntry(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
assertThat(carrier).containsEntry(B3Propagator.SAMPLED_HEADER, "0");
}
@ -141,8 +138,8 @@ class B3PropagatorTest {
@Test
void extract_SampledContext_Int() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), carrier, getter)))
@ -154,8 +151,8 @@ class B3PropagatorTest {
@Test
void extract_SampledContext_Bool() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(B3Propagator.SAMPLED_HEADER, "true");
assertThat(getSpanContext(b3Propagator.extract(Context.current(), carrier, getter)))
@ -167,8 +164,8 @@ class B3PropagatorTest {
@Test
void extract_NotSampledContext() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(B3Propagator.SAMPLED_HEADER, Common.FALSE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), carrier, getter)))
@ -180,47 +177,47 @@ class B3PropagatorTest {
@Test
void extract_SampledContext_Int_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(B3Propagator.TRACE_ID_HEADER, SHORT_TRACE_ID_BASE16);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(B3Propagator.TRACE_ID_HEADER, SHORT_TRACE_ID);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
void extract_SampledContext_Bool_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(B3Propagator.TRACE_ID_HEADER, SHORT_TRACE_ID_BASE16);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(B3Propagator.TRACE_ID_HEADER, SHORT_TRACE_ID);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(B3Propagator.SAMPLED_HEADER, "true");
assertThat(getSpanContext(b3Propagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
void extract_NotSampledContext_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(B3Propagator.TRACE_ID_HEADER, SHORT_TRACE_ID_BASE16);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(B3Propagator.TRACE_ID_HEADER, SHORT_TRACE_ID);
carrier.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(B3Propagator.SAMPLED_HEADER, Common.FALSE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
}
@Test
void extract_InvalidTraceId_NotHex() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, "g" + TRACE_ID_BASE16.substring(1));
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, "g" + TRACE_ID.substring(1));
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
invalidHeaders.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -229,8 +226,8 @@ class B3PropagatorTest {
@Test
void extract_InvalidTraceId_TooShort() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16.substring(2));
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID.substring(2));
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
invalidHeaders.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -239,8 +236,8 @@ class B3PropagatorTest {
@Test
void extract_InvalidTraceId_TooLong() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16 + "00");
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID + "00");
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
invalidHeaders.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -250,7 +247,7 @@ class B3PropagatorTest {
void extract_InvalidTraceId_AllZero() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_ALL_ZERO);
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID);
invalidHeaders.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -259,8 +256,8 @@ class B3PropagatorTest {
@Test
void extract_InvalidSpanId_NotHex() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, "g" + SPAN_ID_BASE16.substring(1));
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, "g" + SPAN_ID.substring(1));
invalidHeaders.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -269,8 +266,8 @@ class B3PropagatorTest {
@Test
void extract_InvalidSpanId_TooShort() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16.substring(2));
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID.substring(2));
invalidHeaders.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -279,8 +276,8 @@ class B3PropagatorTest {
@Test
void extract_InvalidSpanId_TooLong() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_BASE16 + "00");
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID + "00");
invalidHeaders.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -289,7 +286,7 @@ class B3PropagatorTest {
@Test
void extract_InvalidSpanId_AllZeros() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
invalidHeaders.put(B3Propagator.TRACE_ID_HEADER, TRACE_ID);
invalidHeaders.put(B3Propagator.SPAN_ID_HEADER, SPAN_ID_ALL_ZERO);
invalidHeaders.put(B3Propagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
@ -323,8 +320,7 @@ class B3PropagatorTest {
setter);
assertThat(carrier)
.containsEntry(
B3Propagator.COMBINED_HEADER, TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + "1");
.containsEntry(B3Propagator.COMBINED_HEADER, TRACE_ID + "-" + SPAN_ID + "-" + "1");
}
@Test
@ -338,8 +334,7 @@ class B3PropagatorTest {
setter);
assertThat(carrier)
.containsEntry(
B3Propagator.COMBINED_HEADER, TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + "0");
.containsEntry(B3Propagator.COMBINED_HEADER, TRACE_ID + "-" + SPAN_ID + "-" + "0");
}
@Test
@ -354,9 +349,7 @@ class B3PropagatorTest {
@Test
void extract_SampledContext_Int_SingleHeader() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER,
TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + Common.TRUE_INT);
carrier.put(B3Propagator.COMBINED_HEADER, TRACE_ID + "-" + SPAN_ID + "-" + Common.TRUE_INT);
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
@ -368,8 +361,7 @@ class B3PropagatorTest {
void extract_SampledContext_DebugFlag_SingleHeader() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER,
TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + Common.TRUE_INT + "-" + "0");
B3Propagator.COMBINED_HEADER, TRACE_ID + "-" + SPAN_ID + "-" + Common.TRUE_INT + "-" + "0");
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
@ -380,8 +372,7 @@ class B3PropagatorTest {
@Test
void extract_SampledContext_Bool_SingleHeader() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER, TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + "true");
carrier.put(B3Propagator.COMBINED_HEADER, TRACE_ID + "-" + SPAN_ID + "-" + "true");
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
@ -392,9 +383,7 @@ class B3PropagatorTest {
@Test
void extract_SampledContext_Bool_DebugFlag_SingleHeader() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER,
TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + "true" + "-" + "0");
carrier.put(B3Propagator.COMBINED_HEADER, TRACE_ID + "-" + SPAN_ID + "-" + "true" + "-" + "0");
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
@ -405,9 +394,7 @@ class B3PropagatorTest {
@Test
void extract_NotSampledContext_SingleHeader() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER,
TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + Common.FALSE_INT);
carrier.put(B3Propagator.COMBINED_HEADER, TRACE_ID + "-" + SPAN_ID + "-" + Common.FALSE_INT);
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
@ -419,13 +406,12 @@ class B3PropagatorTest {
void extract_SampledContext_Int_SingleHeader_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER,
SHORT_TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + Common.TRUE_INT);
B3Propagator.COMBINED_HEADER, SHORT_TRACE_ID + "-" + SPAN_ID + "-" + Common.TRUE_INT);
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
@ -433,50 +419,47 @@ class B3PropagatorTest {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER,
SHORT_TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + Common.TRUE_INT + "-" + "0");
SHORT_TRACE_ID + "-" + SPAN_ID + "-" + Common.TRUE_INT + "-" + "0");
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
void extract_SampledContext_Bool_SingleHeader_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER, SHORT_TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + "true");
carrier.put(B3Propagator.COMBINED_HEADER, SHORT_TRACE_ID + "-" + SPAN_ID + "-" + "true");
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
void extract_SampledContext_Bool_DebugFlag_SingleHeader_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER,
SHORT_TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + "true" + "-" + "0");
B3Propagator.COMBINED_HEADER, SHORT_TRACE_ID + "-" + SPAN_ID + "-" + "true" + "-" + "0");
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
void extract_NotSampledContext_SingleHeader_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(
B3Propagator.COMBINED_HEADER,
SHORT_TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + Common.FALSE_INT);
B3Propagator.COMBINED_HEADER, SHORT_TRACE_ID + "-" + SPAN_ID + "-" + Common.FALSE_INT);
assertThat(getSpanContext(b3PropagatorSingleHeader.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
}
@Test
@ -506,7 +489,7 @@ class B3PropagatorTest {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(
B3Propagator.COMBINED_HEADER,
"abcdefghijklmnopabcdefghijklmnop" + "-" + SPAN_ID_BASE16 + "-" + Common.TRUE_INT);
"abcdefghijklmnopabcdefghijklmnop" + "-" + SPAN_ID + "-" + Common.TRUE_INT);
assertThat(
getSpanContext(
@ -519,7 +502,7 @@ class B3PropagatorTest {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(
B3Propagator.COMBINED_HEADER,
"abcdefghijklmnopabcdefghijklmnop" + "00" + "-" + SPAN_ID_BASE16 + "-" + Common.TRUE_INT);
"abcdefghijklmnopabcdefghijklmnop" + "00" + "-" + SPAN_ID + "-" + Common.TRUE_INT);
assertThat(
getSpanContext(
@ -531,8 +514,7 @@ class B3PropagatorTest {
void extract_InvalidSpanId_SingleHeader() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(
B3Propagator.COMBINED_HEADER,
TRACE_ID_BASE16 + "-" + "abcdefghijklmnop" + "-" + Common.TRUE_INT);
B3Propagator.COMBINED_HEADER, TRACE_ID + "-" + "abcdefghijklmnop" + "-" + Common.TRUE_INT);
assertThat(
getSpanContext(
@ -545,7 +527,7 @@ class B3PropagatorTest {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(
B3Propagator.COMBINED_HEADER,
TRACE_ID_BASE16 + "-" + "abcdefghijklmnop" + "00" + "-" + Common.TRUE_INT);
TRACE_ID + "-" + "abcdefghijklmnop" + "00" + "-" + Common.TRUE_INT);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -554,7 +536,7 @@ class B3PropagatorTest {
@Test
void extract_TooFewParts_SingleHeader() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(B3Propagator.COMBINED_HEADER, TRACE_ID_BASE16);
invalidHeaders.put(B3Propagator.COMBINED_HEADER, TRACE_ID);
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -564,8 +546,7 @@ class B3PropagatorTest {
void extract_TooManyParts_SingleHeader() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(
B3Propagator.COMBINED_HEADER,
TRACE_ID_BASE16 + "-" + SPAN_ID_BASE16 + "-" + Common.TRUE_INT + "-extra");
B3Propagator.COMBINED_HEADER, TRACE_ID + "-" + SPAN_ID + "-" + Common.TRUE_INT + "-extra");
assertThat(getSpanContext(b3Propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());

7
extensions/trace_propagators/src/test/java/io/opentelemetry/extensions/trace/propagation/JaegerPropagatorTest.java
View File

@ -48,13 +48,14 @@ class JaegerPropagatorTest {
private static final long TRACE_ID_HI = 77L;
private static final long TRACE_ID_LOW = 22L;
private static final String TRACE_ID_BASE16 = "000000000000004d0000000000000016";
private static final TraceId TRACE_ID = new TraceId(TRACE_ID_HI, TRACE_ID_LOW);
private static final String TRACE_ID = TraceId.fromLongs(TRACE_ID_HI, TRACE_ID_LOW);
private static final long SHORT_TRACE_ID_HI = 0L;
private static final long SHORT_TRACE_ID_LOW = 2322222L;
private static final TraceId SHORT_TRACE_ID = new TraceId(SHORT_TRACE_ID_HI, SHORT_TRACE_ID_LOW);
private static final String SHORT_TRACE_ID =
TraceId.fromLongs(SHORT_TRACE_ID_HI, SHORT_TRACE_ID_LOW);
private static final String SPAN_ID_BASE16 = "0000000000017c29";
private static final long SPAN_ID_LONG = 97321L;
private static final SpanId SPAN_ID = new SpanId(SPAN_ID_LONG);
private static final String SPAN_ID = SpanId.fromLong(SPAN_ID_LONG);
private static final long DEPRECATED_PARENT_SPAN_LONG = 0L;
private static final byte SAMPLED_TRACE_OPTIONS_BYTES = 1;
private static final TraceFlags SAMPLED_TRACE_OPTIONS =

63
extensions/trace_propagators/src/test/java/io/opentelemetry/extensions/trace/propagation/OtTracerPropagatorTest.java
View File

@ -37,13 +37,10 @@ import org.junit.jupiter.api.Test;
class OtTracerPropagatorTest {
private static final TraceState TRACE_STATE_DEFAULT = TraceState.builder().build();
private static final String TRACE_ID_BASE16 = "ff000000000000000000000000000041";
private static final TraceId TRACE_ID = TraceId.fromLowerBase16(TRACE_ID_BASE16, 0);
private static final String SHORT_TRACE_ID_BASE16 = "ff00000000000000";
private static final TraceId SHORT_TRACE_ID =
TraceId.fromLowerBase16(StringUtils.padLeft(SHORT_TRACE_ID_BASE16, 32), 0);
private static final String SPAN_ID_BASE16 = "ff00000000000041";
private static final SpanId SPAN_ID = SpanId.fromLowerBase16(SPAN_ID_BASE16, 0);
private static final String TRACE_ID = "ff000000000000000000000000000041";
private static final String SHORT_TRACE_ID = "ff00000000000000";
private static final String SHORT_TRACE_ID_FULL = "0000000000000000ff00000000000000";
private static final String SPAN_ID = "ff00000000000041";
private static final byte SAMPLED_TRACE_OPTIONS_BYTES = 1;
private static final TraceFlags SAMPLED_TRACE_OPTIONS =
TraceFlags.fromByte(SAMPLED_TRACE_OPTIONS_BYTES);
@ -84,8 +81,8 @@ class OtTracerPropagatorTest {
Context.current()),
carrier,
setter);
assertThat(carrier).containsEntry(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
assertThat(carrier).containsEntry(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
assertThat(carrier).containsEntry(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID);
assertThat(carrier).containsEntry(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
assertThat(carrier).containsEntry(OtTracerPropagator.SAMPLED_HEADER, "true");
}
@ -98,8 +95,8 @@ class OtTracerPropagatorTest {
Context.current()),
null,
(Setter<Map<String, String>>) (ignored, key, value) -> carrier.put(key, value));
assertThat(carrier).containsEntry(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
assertThat(carrier).containsEntry(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
assertThat(carrier).containsEntry(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID);
assertThat(carrier).containsEntry(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
assertThat(carrier).containsEntry(OtTracerPropagator.SAMPLED_HEADER, "true");
}
@ -112,8 +109,8 @@ class OtTracerPropagatorTest {
Context.current()),
carrier,
setter);
assertThat(carrier).containsEntry(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
assertThat(carrier).containsEntry(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
assertThat(carrier).containsEntry(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID);
assertThat(carrier).containsEntry(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
assertThat(carrier).containsEntry(OtTracerPropagator.SAMPLED_HEADER, "false");
}
@ -128,8 +125,8 @@ class OtTracerPropagatorTest {
@Test
void extract_SampledContext_Int() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(OtTracerPropagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(propagator.extract(Context.current(), carrier, getter)))
@ -141,8 +138,8 @@ class OtTracerPropagatorTest {
@Test
void extract_SampledContext_Bool() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(OtTracerPropagator.SAMPLED_HEADER, "true");
assertThat(getSpanContext(propagator.extract(Context.current(), carrier, getter)))
@ -154,8 +151,8 @@ class OtTracerPropagatorTest {
@Test
void extract_NotSampledContext() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(OtTracerPropagator.SAMPLED_HEADER, Common.FALSE_INT);
assertThat(getSpanContext(propagator.extract(Context.current(), carrier, getter)))
@ -167,47 +164,47 @@ class OtTracerPropagatorTest {
@Test
void extract_SampledContext_Int_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, SHORT_TRACE_ID_BASE16);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, SHORT_TRACE_ID);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(OtTracerPropagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(propagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
void extract_SampledContext_Bool_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, SHORT_TRACE_ID_BASE16);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, SHORT_TRACE_ID);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(OtTracerPropagator.SAMPLED_HEADER, "true");
assertThat(getSpanContext(propagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, SAMPLED_TRACE_OPTIONS, TRACE_STATE_DEFAULT));
}
@Test
void extract_NotSampledContext_Short_TraceId() {
Map<String, String> carrier = new LinkedHashMap<>();
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, SHORT_TRACE_ID_BASE16);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
carrier.put(OtTracerPropagator.TRACE_ID_HEADER, SHORT_TRACE_ID);
carrier.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
carrier.put(OtTracerPropagator.SAMPLED_HEADER, Common.FALSE_INT);
assertThat(getSpanContext(propagator.extract(Context.current(), carrier, getter)))
.isEqualTo(
SpanContext.createFromRemoteParent(
SHORT_TRACE_ID, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
SHORT_TRACE_ID_FULL, SPAN_ID, TraceFlags.getDefault(), TRACE_STATE_DEFAULT));
}
@Test
void extract_InvalidTraceId() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(OtTracerPropagator.TRACE_ID_HEADER, "abcdefghijklmnopabcdefghijklmnop");
invalidHeaders.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
invalidHeaders.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
invalidHeaders.put(OtTracerPropagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -216,8 +213,8 @@ class OtTracerPropagatorTest {
@Test
void extract_InvalidTraceId_Size() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID_BASE16 + "00");
invalidHeaders.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID_BASE16);
invalidHeaders.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID + "00");
invalidHeaders.put(OtTracerPropagator.SPAN_ID_HEADER, SPAN_ID);
invalidHeaders.put(OtTracerPropagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(propagator.extract(Context.current(), invalidHeaders, getter)))
.isSameAs(SpanContext.getInvalid());
@ -226,7 +223,7 @@ class OtTracerPropagatorTest {
@Test
void extract_InvalidSpanId() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
invalidHeaders.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID);
invalidHeaders.put(OtTracerPropagator.SPAN_ID_HEADER, "abcdefghijklmnop");
invalidHeaders.put(OtTracerPropagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(propagator.extract(Context.current(), invalidHeaders, getter)))
@ -236,7 +233,7 @@ class OtTracerPropagatorTest {
@Test
void extract_InvalidSpanId_Size() {
Map<String, String> invalidHeaders = new LinkedHashMap<>();
invalidHeaders.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID_BASE16);
invalidHeaders.put(OtTracerPropagator.TRACE_ID_HEADER, TRACE_ID);
invalidHeaders.put(OtTracerPropagator.SPAN_ID_HEADER, "abcdefghijklmnop" + "00");
invalidHeaders.put(OtTracerPropagator.SAMPLED_HEADER, Common.TRUE_INT);
assertThat(getSpanContext(propagator.extract(Context.current(), invalidHeaders, getter)))

4
extensions/trace_propagators/src/test/java/io/opentelemetry/extensions/trace/propagation/TraceMultiPropagatorTest.java
View File

@ -50,8 +50,8 @@ class TraceMultiPropagatorTest {
private static final Span SPAN =
DefaultSpan.create(
SpanContext.createFromRemoteParent(
new TraceId(1245, 67890),
new SpanId(12345),
TraceId.fromLongs(1245, 67890),
SpanId.fromLong(12345),
TraceFlags.getDefault(),
TraceState.getDefault()));

4
opentracing_shim/src/main/java/io/opentelemetry/opentracingshim/SpanContextShim.java
View File

@ -67,12 +67,12 @@ final class SpanContextShim extends BaseShimObject implements SpanContext {
@Override
public String toTraceId() {
return context.getTraceId().toString();
return context.getTraceIdAsHexString();
}
@Override
public String toSpanId() {
return context.getSpanId().toString();
return context.getSpanIdAsHexString().toString();
}
@Override

4
opentracing_shim/src/test/java/io/opentelemetry/opentracingshim/SpanShimTest.java
View File

@ -59,8 +59,8 @@ class SpanShimTest {
SpanContextShim contextShim = (SpanContextShim) spanShim.context();
assertNotNull(contextShim);
assertEquals(contextShim.getSpanContext(), span.getContext());
assertEquals(contextShim.toTraceId(), span.getContext().getTraceId().toString());
assertEquals(contextShim.toSpanId(), span.getContext().getSpanId().toString());
assertEquals(contextShim.toTraceId(), span.getContext().getTraceIdAsHexString().toString());
assertEquals(contextShim.toSpanId(), span.getContext().getSpanIdAsHexString().toString());
assertFalse(contextShim.baggageItems().iterator().hasNext());
}

3
opentracing_shim/src/test/java/io/opentelemetry/opentracingshim/testbed/activespanreplacement/ActiveSpanReplacementTest.java
View File

@ -30,6 +30,7 @@ import io.opentelemetry.opentracingshim.TraceShim;
import io.opentelemetry.sdk.correlationcontext.CorrelationContextManagerSdk;
import io.opentelemetry.sdk.trace.TracerSdkProvider;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.trace.SpanId;
import io.opentracing.Scope;
import io.opentracing.Span;
import io.opentracing.Tracer;
@ -73,7 +74,7 @@ class ActiveSpanReplacementTest {
// initial task is not related in any way to those two tasks
assertNotEquals(spans.get(0).getTraceId(), spans.get(1).getTraceId());
assertFalse(spans.get(0).getParentSpanId().isValid());
assertFalse(SpanId.isValid(spans.get(0).getParentSpanId()));
assertNull(tracer.scopeManager().activeSpan());
}

5
opentracing_shim/src/test/java/io/opentelemetry/opentracingshim/testbed/concurrentcommonrequesthandler/HandlerTest.java
View File

@ -30,6 +30,7 @@ import io.opentelemetry.sdk.correlationcontext.CorrelationContextManagerSdk;
import io.opentelemetry.sdk.trace.TracerSdkProvider;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanId;
import io.opentracing.Scope;
import io.opentracing.Span;
import io.opentracing.Tracer;
@ -73,8 +74,8 @@ class HandlerTest {
}
assertNotEquals(finished.get(0).getTraceId(), finished.get(1).getTraceId());
assertFalse(finished.get(0).getParentSpanId().isValid());
assertFalse(finished.get(1).getParentSpanId().isValid());
assertFalse(SpanId.isValid(finished.get(0).getParentSpanId()));
assertFalse(SpanId.isValid(finished.get(1).getParentSpanId()));
assertNull(tracer.scopeManager().activeSpan());
}

6
opentracing_shim/src/test/java/io/opentelemetry/opentracingshim/testbed/promisepropagation/PromisePropagationTest.java
View File

@ -115,14 +115,14 @@ class PromisePropagationTest {
assertThat(getByAttr(finished, component, "success")).hasSize(2);
SpanId parentId = spanExamplePromise.get(0).getSpanId();
CharSequence parentId = spanExamplePromise.get(0).getSpanId();
for (SpanData span : getByAttr(finished, component, "success")) {
assertThat(span.getParentSpanId()).isEqualTo(parentId);
assertThat(span.getParentSpanId()).isEqualTo(parentId.toString());
}
List<SpanData> spanError = getByAttr(finished, component, "error");
assertThat(spanError).hasSize(1);
assertThat(spanError.get(0).getParentSpanId()).isEqualTo(parentId);
assertThat(spanError.get(0).getParentSpanId()).isEqualTo(parentId.toString());
}
}
}

5
opentracing_shim/src/test/java/io/opentelemetry/opentracingshim/testbed/suspendresumepropagation/SuspendResumePropagationTest.java
View File

@ -23,6 +23,7 @@ import io.opentelemetry.opentracingshim.TraceShim;
import io.opentelemetry.sdk.correlationcontext.CorrelationContextManagerSdk;
import io.opentelemetry.sdk.trace.TracerSdkProvider;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.trace.SpanId;
import io.opentracing.Tracer;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
@ -65,7 +66,7 @@ class SuspendResumePropagationTest {
assertThat(finished.get(0).getName()).isEqualTo("job 1");
assertThat(finished.get(1).getName()).isEqualTo("job 2");
assertThat(finished.get(0).getParentSpanId().isValid()).isFalse();
assertThat(finished.get(1).getParentSpanId().isValid()).isFalse();
assertThat(SpanId.isValid(finished.get(0).getParentSpanId())).isFalse();
assertThat(SpanId.isValid(finished.get(1).getParentSpanId())).isFalse();
}
}

4
sdk/all/src/jmh/java/io/opentelemetry/sdk/trace/export/MultiSpanExporterBenchmark.java
View File

@ -79,8 +79,8 @@ public class MultiSpanExporterBenchmark {
for (int i = 0; i < spans.length; i++) {
spans[i] =
TestSpanData.newBuilder()
.setTraceId(new TraceId(1, 1))
.setSpanId(new SpanId(1))
.setTraceId(TraceId.fromLongs(1, 1))
.setSpanId(SpanId.fromLong(1))
.setName("noop")
.setKind(Span.Kind.CLIENT)
.setStartEpochNanos(1)

9
sdk/tracing/src/main/java/io/opentelemetry/sdk/trace/IdsGenerator.java
View File

@ -19,22 +19,19 @@ package io.opentelemetry.sdk.trace;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.TraceId;
/**
* Interface that is used by the {@link TracerSdk} to generate new {@link SpanId} and {@link
* TraceId}.
*/
/** Interface used by the {@link TracerSdk} to generate new {@link SpanId}s and {@link TraceId}s. */
public interface IdsGenerator {
/**
* Generates a new valid {@code SpanId}.
*
* @return a new valid {@code SpanId}.
*/
SpanId generateSpanId();
String generateSpanId();
/**
* Generates a new valid {@code TraceId}.
*
* @return a new valid {@code TraceId}.
*/
TraceId generateTraceId();
String generateTraceId();
}

8
sdk/tracing/src/main/java/io/opentelemetry/sdk/trace/RandomIdsGenerator.java
View File

@ -29,17 +29,17 @@ public final class RandomIdsGenerator implements IdsGenerator {
private static final long INVALID_ID = 0;
@Override
public SpanId generateSpanId() {
public String generateSpanId() {
long id;
ThreadLocalRandom random = ThreadLocalRandom.current();
do {
id = random.nextLong();
} while (id == INVALID_ID);
return new SpanId(id);
return SpanId.fromLong(id);
}
@Override
public TraceId generateTraceId() {
public String generateTraceId() {
long idHi;
long idLo;
ThreadLocalRandom random = ThreadLocalRandom.current();
@ -47,6 +47,6 @@ public final class RandomIdsGenerator implements IdsGenerator {
idHi = random.nextLong();
idLo = random.nextLong();
} while (idHi == INVALID_ID && idLo == INVALID_ID);
return new TraceId(idHi, idLo);
return TraceId.fromLongs(idHi, idLo);
}
}

13
sdk/tracing/src/main/java/io/opentelemetry/sdk/trace/RecordEventsReadableSpan.java
View File

@ -33,7 +33,6 @@ import io.opentelemetry.sdk.trace.data.SpanData.Link;
import io.opentelemetry.trace.EndSpanOptions;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.Tracer;
import io.opentelemetry.trace.attributes.SemanticAttributes;
@ -60,7 +59,7 @@ final class RecordEventsReadableSpan implements ReadWriteSpan {
// Contains the identifiers associated with this Span.
private final SpanContext context;
// The parent SpanId of this span. Invalid if this is a root span.
private final SpanId parentSpanId;
private final String parentSpanId;
// True if the parent is on a different process.
private final boolean hasRemoteParent;
// Handler called when the span starts and ends.
@ -112,7 +111,7 @@ final class RecordEventsReadableSpan implements ReadWriteSpan {
String name,
InstrumentationLibraryInfo instrumentationLibraryInfo,
Kind kind,
SpanId parentSpanId,
String parentSpanId,
boolean hasRemoteParent,
TraceConfig traceConfig,
SpanProcessor spanProcessor,
@ -163,7 +162,7 @@ final class RecordEventsReadableSpan implements ReadWriteSpan {
String name,
InstrumentationLibraryInfo instrumentationLibraryInfo,
Kind kind,
SpanId parentSpanId,
@Nullable String parentSpanId,
boolean hasRemoteParent,
TraceConfig traceConfig,
SpanProcessor spanProcessor,
@ -507,7 +506,7 @@ final class RecordEventsReadableSpan implements ReadWriteSpan {
}
}
SpanId getParentSpanId() {
String getParentSpanId() {
return parentSpanId;
}
@ -609,9 +608,9 @@ final class RecordEventsReadableSpan implements ReadWriteSpan {
}
StringBuilder sb = new StringBuilder();
sb.append("RecordEventsReadableSpan{traceId=");
sb.append(context.getTraceId());
sb.append(context.getTraceIdAsHexString());
sb.append(", spanId=");
sb.append(context.getSpanId());
sb.append(context.getSpanIdAsHexString());
sb.append(", parentSpanId=");
sb.append(parentSpanId);
sb.append(", name=");

4
sdk/tracing/src/main/java/io/opentelemetry/sdk/trace/Sampler.java
View File

@ -50,7 +50,7 @@ public interface Sampler {
*/
SamplingResult shouldSample(
SpanContext parentContext,
TraceId traceId,
String traceId,
String name,
Kind spanKind,
ReadableAttributes attributes,
@ -75,7 +75,7 @@ public interface Sampler {
}
/**
* Sampling result returned by {@link Sampler#shouldSample(SpanContext, TraceId, String, Kind,
* Sampling result returned by {@link Sampler#shouldSample(SpanContext, String, String, Kind,
* ReadableAttributes, List)}.
*
* @since 0.1.0

10
sdk/tracing/src/main/java/io/opentelemetry/sdk/trace/Samplers.java
View File

@ -190,7 +190,7 @@ public final class Samplers {
@Override
public SamplingResult shouldSample(
SpanContext parentContext,
TraceId traceId,
String traceId,
String name,
Kind spanKind,
ReadableAttributes attributes,
@ -212,7 +212,7 @@ public final class Samplers {
@Override
public SamplingResult shouldSample(
SpanContext parentContext,
TraceId traceId,
String traceId,
String name,
Kind spanKind,
ReadableAttributes attributes,
@ -254,7 +254,7 @@ public final class Samplers {
@Override
public SamplingResult shouldSample(
SpanContext parentContext,
TraceId traceId,
String traceId,
String name,
Kind spanKind,
ReadableAttributes attributes,
@ -468,7 +468,7 @@ public final class Samplers {
@Override
public final SamplingResult shouldSample(
SpanContext parentContext,
TraceId traceId,
String traceId,
String name,
Kind spanKind,
ReadableAttributes attributes,
@ -481,7 +481,7 @@ public final class Samplers {
// while allowing for a (very) small chance of *not* sampling if the id == Long.MAX_VALUE.
// This is considered a reasonable tradeoff for the simplicity/performance requirements (this
// code is executed in-line for every Span creation).
return Math.abs(traceId.getTraceRandomPart()) < getIdUpperBound()
return Math.abs(TraceId.getTraceIdRandomPart(traceId)) < getIdUpperBound()
? getPositiveSamplingResult()
: getNegativeSamplingResult();
}

26
sdk/tracing/src/main/java/io/opentelemetry/sdk/trace/SpanBuilderSdk.java
View File

@ -34,9 +34,7 @@ import io.opentelemetry.trace.DefaultSpan;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
import io.opentelemetry.trace.TracingContextUtils;
import java.util.ArrayList;
@ -210,15 +208,15 @@ final class SpanBuilderSdk implements Span.Builder {
@Override
public Span startSpan() {
SpanContext parentContext = parent(parentType, parent, remoteParent);
TraceId traceId;
SpanId spanId = idsGenerator.generateSpanId();
String traceId;
String spanId = idsGenerator.generateSpanId();
TraceState traceState = TraceState.getDefault();
if (!parentContext.isValid()) {
// New root span.
traceId = idsGenerator.generateTraceId();
} else {
// New child span.
traceId = parentContext.getTraceId();
traceId = parentContext.getTraceIdAsHexString();
traceState = parentContext.getTraceState();
}
List<io.opentelemetry.trace.Link> immutableLinks =
@ -236,14 +234,9 @@ final class SpanBuilderSdk implements Span.Builder {
parentContext, traceId, spanName, spanKind, immutableAttributes, immutableLinks);
Sampler.Decision samplingDecision = samplingResult.getDecision();
SpanContext spanContext =
SpanContext.create(
traceId,
spanId,
Samplers.isSampled(samplingDecision)
? TRACE_OPTIONS_SAMPLED
: TRACE_OPTIONS_NOT_SAMPLED,
traceState);
TraceFlags traceFlags =
Samplers.isSampled(samplingDecision) ? TRACE_OPTIONS_SAMPLED : TRACE_OPTIONS_NOT_SAMPLED;
SpanContext spanContext = createSpanContext(traceId, spanId, traceState, traceFlags);
if (!Samplers.isRecording(samplingDecision)) {
return DefaultSpan.create(spanContext);
@ -272,7 +265,7 @@ final class SpanBuilderSdk implements Span.Builder {
spanName,
instrumentationLibraryInfo,
spanKind,
parentContext.getSpanId(),
parentContext.getSpanIdAsHexString(),
parentContext.isRemote(),
traceConfig,
spanProcessor,
@ -284,6 +277,11 @@ final class SpanBuilderSdk implements Span.Builder {
startEpochNanos);
}
private static SpanContext createSpanContext(
String traceId, String spanId, TraceState traceState, TraceFlags traceFlags) {
return SpanContext.create(traceId, spanId, traceFlags, traceState);
}
private static Clock getClock(Span parent, Clock clock) {
if (parent instanceof RecordEventsReadableSpan) {
RecordEventsReadableSpan parentRecordEventsSpan = (RecordEventsReadableSpan) parent;

12
sdk/tracing/src/main/java/io/opentelemetry/sdk/trace/SpanWrapper.java
View File

@ -22,10 +22,8 @@ import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
import java.util.List;
import javax.annotation.concurrent.Immutable;
@ -92,13 +90,13 @@ abstract class SpanWrapper implements SpanData {
}
@Override
public TraceId getTraceId() {
return delegate().getContext().getTraceId();
public String getTraceId() {
return delegate().getContext().getTraceIdAsHexString();
}
@Override
public SpanId getSpanId() {
return delegate().getContext().getSpanId();
public String getSpanId() {
return delegate().getContext().getSpanIdAsHexString();
}
@Override
@ -112,7 +110,7 @@ abstract class SpanWrapper implements SpanData {
}
@Override
public SpanId getParentSpanId() {
public String getParentSpanId() {
return delegate().getParentSpanId();
}

8
sdk/tracing/src/main/java/io/opentelemetry/sdk/trace/data/SpanData.java
View File

@ -24,10 +24,8 @@ import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.config.TraceConfig;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
import java.util.List;
import javax.annotation.concurrent.Immutable;
@ -45,14 +43,14 @@ public interface SpanData {
*
* @return the trace id.
*/
TraceId getTraceId();
String getTraceId();
/**
* Gets the span id for this span.
*
* @return the span id.
*/
SpanId getSpanId();
String getSpanId();
/**
* Gets the trace flags for this span.
@ -75,7 +73,7 @@ public interface SpanData {
* @return the parent {@code SpanId} or an invalid SpanId if this is a root {@code Span}.
* @since 0.1.0
*/
SpanId getParentSpanId();
String getParentSpanId();
/**
* Returns the resource of this {@code Span}.

8
sdk/tracing/src/test/java/io/opentelemetry/sdk/trace/RandomIdsGeneratorTest.java
View File

@ -30,11 +30,11 @@ class RandomIdsGeneratorTest {
// Can't assert values but can assert they're valid, try a lot as a sort of fuzz check.
for (int i = 0; i < 1000; i++) {
TraceId traceId = generator.generateTraceId();
assertThat(traceId).isNotEqualTo(TraceId.getInvalid());
CharSequence traceId = generator.generateTraceId();
assertThat(traceId.toString()).isNotEqualTo(TraceId.getInvalid());
SpanId spanId = generator.generateSpanId();
assertThat(spanId).isNotEqualTo(SpanId.getInvalid());
CharSequence spanId = generator.generateSpanId();
assertThat(spanId.toString()).isNotEqualTo(SpanId.getInvalid());
}
}
}

17
sdk/tracing/src/test/java/io/opentelemetry/sdk/trace/RecordEventsReadableSpanTest.java
View File

@ -36,7 +36,6 @@ import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
import java.io.PrintWriter;
import java.io.StringWriter;
@ -66,9 +65,9 @@ class RecordEventsReadableSpanTest {
private static final long START_EPOCH_NANOS = 1000_123_789_654L;
private final IdsGenerator idsGenerator = new RandomIdsGenerator();
private final TraceId traceId = idsGenerator.generateTraceId();
private final SpanId spanId = idsGenerator.generateSpanId();
private final SpanId parentSpanId = idsGenerator.generateSpanId();
private final String traceId = idsGenerator.generateTraceId();
private final String spanId = idsGenerator.generateSpanId();
private final String parentSpanId = idsGenerator.generateSpanId();
private final SpanContext spanContext =
SpanContext.create(traceId, spanId, TraceFlags.getDefault(), TraceState.getDefault());
private final Resource resource = Resource.getEmpty();
@ -236,7 +235,7 @@ class RecordEventsReadableSpanTest {
span.end();
}
SpanData spanData = span.toSpanData();
assertThat(spanData.getParentSpanId().isValid()).isFalse();
assertThat(SpanId.isValid(spanData.getParentSpanId())).isFalse();
}
@Test
@ -814,7 +813,7 @@ class RecordEventsReadableSpanTest {
private RecordEventsReadableSpan createTestSpan(
Kind kind,
TraceConfig config,
@Nullable SpanId parentSpanId,
@Nullable String parentSpanId,
@Nullable AttributesMap attributes,
List<io.opentelemetry.trace.Link> links) {
@ -888,9 +887,9 @@ class RecordEventsReadableSpanTest {
void testAsSpanData() {
String name = "GreatSpan";
Kind kind = Kind.SERVER;
TraceId traceId = this.traceId;
SpanId spanId = this.spanId;
SpanId parentSpanId = this.parentSpanId;
String traceId = this.traceId;
String spanId = this.spanId;
String parentSpanId = this.parentSpanId;
TraceConfig traceConfig = TraceConfig.getDefault();
SpanProcessor spanProcessor = NoopSpanProcessor.getInstance();
TestClock clock = TestClock.create();

19
sdk/tracing/src/test/java/io/opentelemetry/sdk/trace/SamplersTest.java
View File

@ -27,7 +27,6 @@ import io.opentelemetry.sdk.trace.Sampler.SamplingResult;
import io.opentelemetry.sdk.trace.data.SpanData.Link;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
@ -41,8 +40,8 @@ class SamplersTest {
private static final Span.Kind SPAN_KIND = Span.Kind.INTERNAL;
private static final int NUM_SAMPLE_TRIES = 1000;
private final IdsGenerator idsGenerator = new RandomIdsGenerator();
private final TraceId traceId = idsGenerator.generateTraceId();
private final SpanId parentSpanId = idsGenerator.generateSpanId();
private final String traceId = idsGenerator.generateTraceId();
private final String parentSpanId = idsGenerator.generateSpanId();
private final TraceState traceState = TraceState.builder().build();
private final SpanContext sampledSpanContext =
SpanContext.create(
@ -692,8 +691,8 @@ class SamplersTest {
final Sampler defaultProbability = Samplers.Probability.create(0.0001);
// This traceId will not be sampled by the Probability Sampler because the last 8 bytes as long
// is not less than probability * Long.MAX_VALUE;
TraceId notSampledtraceId =
TraceId.fromBytes(
String notSampledtraceId =
TraceId.bytesToHex(
new byte[] {
0,
0,
@ -711,8 +710,7 @@ class SamplersTest {
(byte) 0xFF,
(byte) 0xFF,
(byte) 0xFF
},
0);
});
SamplingResult samplingResult1 =
defaultProbability.shouldSample(
invalidSpanContext,
@ -727,8 +725,8 @@ class SamplersTest {
Attributes.of(Samplers.SAMPLING_PROBABILITY.key(), doubleAttributeValue(0.0001)));
// This traceId will be sampled by the Probability Sampler because the last 8 bytes as long
// is less than probability * Long.MAX_VALUE;
TraceId sampledtraceId =
TraceId.fromBytes(
String sampledtraceId =
TraceId.bytesToHex(
new byte[] {
(byte) 0x00,
(byte) 0x00,
@ -746,8 +744,7 @@ class SamplersTest {
0,
0,
0
},
0);
});
SamplingResult samplingResult2 =
defaultProbability.shouldSample(
invalidSpanContext,

53
sdk/tracing/src/test/java/io/opentelemetry/sdk/trace/SpanBuilderSdkTest.java
View File

@ -47,8 +47,8 @@ class SpanBuilderSdkTest {
private static final String SPAN_NAME = "span_name";
private final SpanContext sampledSpanContext =
SpanContext.create(
new TraceId(1000, 1000),
new SpanId(3000),
TraceId.fromLongs(1000, 1000),
SpanId.fromLong(3000),
TraceFlags.builder().setIsSampled(true).build(),
TraceState.getDefault());
@ -162,8 +162,8 @@ class SpanBuilderSdkTest {
// this test to pass.
spanBuilder.addLink(
SpanContext.create(
new TraceId(2000, 2000),
new SpanId(4000),
TraceId.fromLongs(2000, 2000),
SpanId.fromLong(4000),
TraceFlags.builder().setIsSampled(true).build(),
TraceState.getDefault()));
assertThat(span.toSpanData().getLinks())
@ -553,7 +553,7 @@ class SpanBuilderSdkTest {
@Override
public SamplingResult shouldSample(
@Nullable SpanContext parentContext,
TraceId traceId,
String traceId,
String name,
Kind spanKind,
ReadableAttributes attributes,
@ -610,7 +610,8 @@ class SpanBuilderSdkTest {
try (Scope ignored = tracerSdk.withSpan(parent)) {
Span span = tracerSdk.spanBuilder(SPAN_NAME).setNoParent().startSpan();
try {
assertThat(span.getContext().getTraceId()).isNotEqualTo(parent.getContext().getTraceId());
assertThat(span.getContext().getTraceIdAsHexString())
.isNotEqualTo(parent.getContext().getTraceIdAsHexString());
Span spanNoParent =
tracerSdk
@ -620,7 +621,8 @@ class SpanBuilderSdkTest {
.setNoParent()
.startSpan();
try {
assertThat(span.getContext().getTraceId()).isNotEqualTo(parent.getContext().getTraceId());
assertThat(span.getContext().getTraceIdAsHexString())
.isNotEqualTo(parent.getContext().getTraceIdAsHexString());
} finally {
spanNoParent.end();
}
@ -640,8 +642,10 @@ class SpanBuilderSdkTest {
(RecordEventsReadableSpan)
tracerSdk.spanBuilder(SPAN_NAME).setNoParent().setParent(parent).startSpan();
try {
assertThat(span.getContext().getTraceId()).isEqualTo(parent.getContext().getTraceId());
assertThat(span.toSpanData().getParentSpanId()).isEqualTo(parent.getContext().getSpanId());
assertThat(span.getContext().getTraceIdAsHexString())
.isEqualTo(parent.getContext().getTraceIdAsHexString());
assertThat(span.toSpanData().getParentSpanId())
.isEqualTo(parent.getContext().getSpanIdAsHexString());
RecordEventsReadableSpan span2 =
(RecordEventsReadableSpan)
@ -651,7 +655,8 @@ class SpanBuilderSdkTest {
.setParent(parent.getContext())
.startSpan();
try {
assertThat(span2.getContext().getTraceId()).isEqualTo(parent.getContext().getTraceId());
assertThat(span2.getContext().getTraceIdAsHexString())
.isEqualTo(parent.getContext().getTraceIdAsHexString());
} finally {
span2.end();
}
@ -676,8 +681,10 @@ class SpanBuilderSdkTest {
.setParent(parent.getContext())
.startSpan();
try {
assertThat(span.getContext().getTraceId()).isEqualTo(parent.getContext().getTraceId());
assertThat(span.toSpanData().getParentSpanId()).isEqualTo(parent.getContext().getSpanId());
assertThat(span.getContext().getTraceIdAsHexString())
.isEqualTo(parent.getContext().getTraceIdAsHexString());
assertThat(span.toSpanData().getParentSpanId())
.isEqualTo(parent.getContext().getSpanIdAsHexString());
} finally {
span.end();
}
@ -695,8 +702,10 @@ class SpanBuilderSdkTest {
(RecordEventsReadableSpan)
tracerSdk.spanBuilder(SPAN_NAME).setNoParent().setParent(context).startSpan();
try {
assertThat(span.getContext().getTraceId()).isEqualTo(parent.getContext().getTraceId());
assertThat(span.toSpanData().getParentSpanId()).isEqualTo(parent.getContext().getSpanId());
assertThat(span.getContext().getTraceIdAsHexString())
.isEqualTo(parent.getContext().getTraceIdAsHexString());
assertThat(span.toSpanData().getParentSpanId())
.isEqualTo(parent.getContext().getSpanIdAsHexString());
} finally {
span.end();
}
@ -718,9 +727,10 @@ class SpanBuilderSdkTest {
}
try {
assertThat(span.getContext().getTraceId()).isNotEqualTo(parent.getContext().getTraceId());
assertThat(span.getContext().getTraceIdAsHexString())
.isNotEqualTo(parent.getContext().getTraceIdAsHexString());
assertThat(span.toSpanData().getParentSpanId())
.isNotEqualTo(parent.getContext().getSpanId());
.isNotEqualTo(parent.getContext().getSpanIdAsHexString());
} finally {
span.end();
}
@ -736,8 +746,10 @@ class SpanBuilderSdkTest {
RecordEventsReadableSpan span =
(RecordEventsReadableSpan) tracerSdk.spanBuilder(SPAN_NAME).startSpan();
try {
assertThat(span.getContext().getTraceId()).isEqualTo(parent.getContext().getTraceId());
assertThat(span.toSpanData().getParentSpanId()).isEqualTo(parent.getContext().getSpanId());
assertThat(span.getContext().getTraceIdAsHexString())
.isEqualTo(parent.getContext().getTraceIdAsHexString());
assertThat(span.toSpanData().getParentSpanId())
.isEqualTo(parent.getContext().getSpanIdAsHexString());
} finally {
span.end();
}
@ -754,8 +766,9 @@ class SpanBuilderSdkTest {
(RecordEventsReadableSpan)
tracerSdk.spanBuilder(SPAN_NAME).setParent(parent.getContext()).startSpan();
try {
assertThat(span.getContext().getTraceId()).isNotEqualTo(parent.getContext().getTraceId());
assertFalse(span.toSpanData().getParentSpanId().isValid());
assertThat(span.getContext().getTraceIdAsHexString())
.isNotEqualTo(parent.getContext().getTraceIdAsHexString());
assertFalse(SpanId.isValid(span.toSpanData().getParentSpanId()));
} finally {
span.end();
}

7
sdk_extensions/aws_v1_support/src/main/java/io/opentelemetry/sdk/extensions/trace/aws/AwsXRayIdsGenerator.java
View File

@ -18,7 +18,6 @@ package io.opentelemetry.sdk.extensions.trace.aws;
import io.opentelemetry.sdk.trace.IdsGenerator;
import io.opentelemetry.sdk.trace.RandomIdsGenerator;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.TraceId;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
@ -38,12 +37,12 @@ public class AwsXRayIdsGenerator implements IdsGenerator {
private static final RandomIdsGenerator RANDOM_IDS_GENERATOR = new RandomIdsGenerator();
@Override
public SpanId generateSpanId() {
public String generateSpanId() {
return RANDOM_IDS_GENERATOR.generateSpanId();
}
@Override
public TraceId generateTraceId() {
public String generateTraceId() {
// hi - 4 bytes timestamp, 4 bytes random
// low - 8 bytes random.
// Since we include timestamp, impossible to be invalid.
@ -54,6 +53,6 @@ public class AwsXRayIdsGenerator implements IdsGenerator {
long lowRandom = random.nextLong();
return new TraceId(timestampSecs << 32 | hiRandom, lowRandom);
return TraceId.fromLongs(timestampSecs << 32 | hiRandom, lowRandom);
}
}

24
sdk_extensions/aws_v1_support/src/test/java/io/opentelemetry/sdk/extensions/trace/aws/AwsXRayIdsGeneratorTest.java
View File

@ -36,10 +36,10 @@ class AwsXRayIdsGeneratorTest {
void shouldGenerateValidIds() {
AwsXRayIdsGenerator generator = new AwsXRayIdsGenerator();
for (int i = 0; i < 1000; i++) {
TraceId traceId = generator.generateTraceId();
assertThat(traceId.isValid()).isTrue();
SpanId spanId = generator.generateSpanId();
assertThat(spanId.isValid()).isTrue();
String traceId = generator.generateTraceId();
assertThat(TraceId.isValid(traceId)).isTrue();
String spanId = generator.generateSpanId();
assertThat(SpanId.isValid(spanId)).isTrue();
}
}
@ -47,8 +47,8 @@ class AwsXRayIdsGeneratorTest {
void shouldGenerateTraceIdsWithTimestampsWithAllowedXrayTimeRange() {
AwsXRayIdsGenerator generator = new AwsXRayIdsGenerator();
for (int i = 0; i < 1000; i++) {
TraceId traceId = generator.generateTraceId();
long unixSeconds = Long.valueOf(traceId.toLowerBase16().substring(0, 8), 16);
String traceId = generator.generateTraceId();
long unixSeconds = Long.valueOf(traceId.subSequence(0, 8).toString(), 16);
long ts = unixSeconds * 1000L;
long currentTs = System.currentTimeMillis();
assertThat(ts).isLessThanOrEqualTo(currentTs);
@ -61,8 +61,8 @@ class AwsXRayIdsGeneratorTest {
void shouldGenerateUniqueIdsInMultithreadedEnvironment()
throws BrokenBarrierException, InterruptedException {
AwsXRayIdsGenerator generator = new AwsXRayIdsGenerator();
Set<TraceId> traceIds = new CopyOnWriteArraySet<>();
Set<SpanId> spanIds = new CopyOnWriteArraySet<>();
Set<String> traceIds = new CopyOnWriteArraySet<>();
Set<String> spanIds = new CopyOnWriteArraySet<>();
int threads = 8;
int generations = 128;
CyclicBarrier barrier = new CyclicBarrier(threads + 1);
@ -81,15 +81,15 @@ class AwsXRayIdsGeneratorTest {
private final int generations;
private final IdsGenerator idsGenerator;
private final CyclicBarrier barrier;
private final Set<TraceId> traceIds;
private final Set<SpanId> spanIds;
private final Set<String> traceIds;
private final Set<String> spanIds;
GenerateRunner(
int generations,
IdsGenerator idsGenerator,
CyclicBarrier barrier,
Set<TraceId> traceIds,
Set<SpanId> spanIds) {
Set<String> traceIds,
Set<String> spanIds) {
this.generations = generations;
this.idsGenerator = idsGenerator;
this.barrier = barrier;

3
sdk_extensions/jaeger_remote_sampler/src/main/java/io/opentelemetry/sdk/extensions/trace/jaeger/sampler/JaegerRemoteSampler.java
View File

@ -30,7 +30,6 @@ import io.opentelemetry.sdk.trace.Samplers;
import io.opentelemetry.trace.Link;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.TraceId;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
@ -79,7 +78,7 @@ public class JaegerRemoteSampler implements Sampler {
@Override
public SamplingResult shouldSample(
SpanContext parentContext,
TraceId traceId,
String traceId,
String name,
Kind spanKind,
ReadableAttributes attributes,

3
sdk_extensions/jaeger_remote_sampler/src/main/java/io/opentelemetry/sdk/extensions/trace/jaeger/sampler/PerOperationSampler.java
View File

@ -23,7 +23,6 @@ import io.opentelemetry.sdk.trace.Samplers;
import io.opentelemetry.trace.Link;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.TraceId;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@ -48,7 +47,7 @@ class PerOperationSampler implements Sampler {
@Override
public SamplingResult shouldSample(
SpanContext parentContext,
TraceId traceId,
String traceId,
String name,
Kind spanKind,
ReadableAttributes attributes,

3
sdk_extensions/jaeger_remote_sampler/src/main/java/io/opentelemetry/sdk/extensions/trace/jaeger/sampler/RateLimitingSampler.java
View File

@ -26,7 +26,6 @@ import io.opentelemetry.sdk.trace.Samplers;
import io.opentelemetry.trace.Link;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanContext;
import io.opentelemetry.trace.TraceId;
import java.util.List;
/**
@ -63,7 +62,7 @@ class RateLimitingSampler implements Sampler {
@Override
public SamplingResult shouldSample(
SpanContext parentContext,
TraceId traceId,
String traceId,
String name,
Kind spanKind,
ReadableAttributes attributes,

4
sdk_extensions/jaeger_remote_sampler/src/test/java/io/opentelemetry/sdk/extensions/trace/jaeger/sampler/RateLimitingSamplerTest.java
View File

@ -35,8 +35,8 @@ import org.junit.jupiter.api.Test;
class RateLimitingSamplerTest {
private static final String SPAN_NAME = "MySpanName";
private static final Span.Kind SPAN_KIND = Span.Kind.INTERNAL;
private final TraceId traceId = new TraceId(150, 150);
private final SpanId parentSpanId = new SpanId(250);
private final String traceId = TraceId.fromLongs(150, 150);
private final String parentSpanId = SpanId.fromLong(250);
private final TraceState traceState = TraceState.builder().build();
private final SpanContext sampledSpanContext =
SpanContext.create(

12
sdk_extensions/otproto/src/main/java/io/opentelemetry/sdk/extensions/otproto/TraceProtoUtils.java
View File

@ -34,10 +34,8 @@ public final class TraceProtoUtils {
* @param spanId the spanId to convert.
* @return a ByteString representation.
*/
public static ByteString toProtoSpanId(SpanId spanId) {
byte[] spanIdBytes = new byte[SpanId.getSize()];
spanId.copyBytesTo(spanIdBytes, 0);
return ByteString.copyFrom(spanIdBytes);
public static ByteString toProtoSpanId(String spanId) {
return ByteString.copyFrom(SpanId.bytesFromHex(spanId, 0));
}
/**
@ -46,10 +44,8 @@ public final class TraceProtoUtils {
* @param traceId the traceId to convert.
* @return a ByteString representation.
*/
public static ByteString toProtoTraceId(TraceId traceId) {
byte[] traceIdBytes = new byte[TraceId.getSize()];
traceId.copyBytesTo(traceIdBytes, 0);
return ByteString.copyFrom(traceIdBytes);
public static ByteString toProtoTraceId(String traceId) {
return ByteString.copyFrom(TraceId.bytesFromHex(traceId, 0));
}
/**

7
sdk_extensions/otproto/src/test/java/io/opentelemetry/sdk/extensions/otproto/TraceProtoUtilsTest.java
View File

@ -43,20 +43,19 @@ class TraceProtoUtilsTest {
private static final byte[] TRACE_ID_BYTES =
new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'a'};
private static final TraceId TRACE_ID = TraceId.fromBytes(TRACE_ID_BYTES, 0);
private static final byte[] SPAN_ID_BYTES = new byte[] {0, 0, 0, 0, 0, 0, 0, 'b'};
private static final SpanId SPAN_ID = SpanId.fromBytes(SPAN_ID_BYTES, 0);
@Test
void toProtoTraceId() {
ByteString expected = ByteString.copyFrom(TRACE_ID_BYTES);
assertThat(TraceProtoUtils.toProtoTraceId(TRACE_ID)).isEqualTo(expected);
assertThat(TraceProtoUtils.toProtoTraceId(TraceId.bytesToHex(TRACE_ID_BYTES)))
.isEqualTo(expected);
}
@Test
void toProtoSpanId() {
ByteString expected = ByteString.copyFrom(SPAN_ID_BYTES);
assertThat(TraceProtoUtils.toProtoSpanId(SPAN_ID)).isEqualTo(expected);
assertThat(TraceProtoUtils.toProtoSpanId(SpanId.bytesToHex(SPAN_ID_BYTES))).isEqualTo(expected);
}
@Test

8
sdk_extensions/testbed/src/test/java/io/opentelemetry/sdk/extensions/trace/testbed/promisepropagation/PromisePropagationTest.java
View File

@ -106,18 +106,18 @@ class PromisePropagationTest {
String component = "component";
SpanData parentSpanProto = TestUtils.getOneByAttr(finished, component, "example-promises");
assertThat(parentSpanProto).isNotNull();
assertThat(parentSpanProto.getParentSpanId().isValid()).isFalse();
assertThat(SpanId.isValid(parentSpanProto.getParentSpanId())).isFalse();
List<SpanData> successSpans = TestUtils.getByAttr(finished, component, "success");
assertThat(successSpans).hasSize(2);
SpanId parentId = parentSpanProto.getSpanId();
CharSequence parentId = parentSpanProto.getSpanId();
for (SpanData span : successSpans) {
assertThat(span.getParentSpanId()).isEqualTo(parentId);
assertThat(span.getParentSpanId()).isEqualTo(parentId.toString());
}
SpanData errorSpan = TestUtils.getOneByAttr(finished, component, "error");
assertThat(errorSpan).isNotNull();
assertThat(errorSpan.getParentSpanId()).isEqualTo(parentId);
assertThat(errorSpan.getParentSpanId()).isEqualTo(parentId.toString());
}
}
}

5
sdk_extensions/testbed/src/test/java/io/opentelemetry/sdk/extensions/trace/testbed/suspendresumepropagation/SuspendResumePropagationTest.java
View File

@ -21,6 +21,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import io.opentelemetry.exporters.inmemory.InMemoryTracing;
import io.opentelemetry.sdk.trace.TracerSdkProvider;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Tracer;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
@ -61,7 +62,7 @@ class SuspendResumePropagationTest {
assertThat(finished.get(0).getName()).isEqualTo("job 1");
assertThat(finished.get(1).getName()).isEqualTo("job 2");
assertThat(finished.get(0).getParentSpanId().isValid()).isFalse();
assertThat(finished.get(1).getParentSpanId().isValid()).isFalse();
assertThat(SpanId.isValid(finished.get(0).getParentSpanId())).isFalse();
assertThat(SpanId.isValid(finished.get(1).getParentSpanId())).isFalse();
}
}

7
sdk_extensions/zpages/src/main/java/io/opentelemetry/sdk/extensions/zpages/TracezSpanProcessor.java
View File

@ -21,7 +21,6 @@ import io.opentelemetry.sdk.common.export.ConfigBuilder;
import io.opentelemetry.sdk.trace.ReadWriteSpan;
import io.opentelemetry.sdk.trace.ReadableSpan;
import io.opentelemetry.sdk.trace.SpanProcessor;
import io.opentelemetry.trace.SpanId;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
@ -50,7 +49,7 @@ import javax.annotation.concurrent.ThreadSafe;
*/
@ThreadSafe
final class TracezSpanProcessor implements SpanProcessor {
private final ConcurrentMap<SpanId, ReadableSpan> runningSpanCache;
private final ConcurrentMap<String, ReadableSpan> runningSpanCache;
private final ConcurrentMap<String, TracezSpanBuckets> completedSpanCache;
private final boolean sampled;
@ -67,7 +66,7 @@ final class TracezSpanProcessor implements SpanProcessor {
@Override
public void onStart(ReadWriteSpan span) {
runningSpanCache.put(span.getSpanContext().getSpanId(), span);
runningSpanCache.put(span.getSpanContext().getSpanIdAsHexString().toString(), span);
}
@Override
@ -77,7 +76,7 @@ final class TracezSpanProcessor implements SpanProcessor {
@Override
public void onEnd(ReadableSpan span) {
runningSpanCache.remove(span.getSpanContext().getSpanId());
runningSpanCache.remove(span.getSpanContext().getSpanIdAsHexString().toString());
if (!sampled || span.getSpanContext().getTraceFlags().isSampled()) {
completedSpanCache.putIfAbsent(span.getName(), new TracezSpanBuckets());
completedSpanCache.get(span.getName()).addToBucket(span);

8
sdk_extensions/zpages/src/main/java/io/opentelemetry/sdk/extensions/zpages/TracezZPageHandler.java
View File

@ -309,11 +309,9 @@ final class TracezZPageHandler extends ZPageHandler {
+ "TraceId: <b style=\"color:%s;\">%s</b> "
+ " | SpanId: %s | ParentSpanId: %s</b></pre></td>",
span.getTraceFlags().isSampled() ? SAMPLED_TRACE_ID_COLOR : NOT_SAMPLED_TRACE_ID_COLOR,
span.getTraceId().toLowerBase16(),
span.getSpanId().toLowerBase16(),
(span.getParentSpanId() == null
? SpanId.getInvalid().toLowerBase16()
: span.getParentSpanId().toLowerBase16()));
span.getTraceId(),
span.getSpanId(),
(span.getParentSpanId() == null ? SpanId.getInvalid() : span.getParentSpanId()));
out.print("</tr>");
zebraStripe = !zebraStripe;

3
sdk_extensions/zpages/src/main/java/io/opentelemetry/sdk/extensions/zpages/ZPageServer.java
View File

@ -89,8 +89,7 @@ public final class ZPageServer {
/** Function that adds the {@link TracezSpanProcessor} to the {@link TracerSdkProvider}. */
private static void addTracezSpanProcessor() {
if (isTracezSpanProcesserAdded.compareAndSet(
/* expectedValue= */ false, /* newValue= */ true)) {
if (isTracezSpanProcesserAdded.compareAndSet(/* expectedValue=*/ false, /* newValue=*/ true)) {
tracerProvider.addSpanProcessor(tracezSpanProcessor);
}
}

30
sdk_extensions/zpages/src/test/java/io/opentelemetry/sdk/extensions/zpages/TracezZPageHandlerTest.java
View File

@ -287,8 +287,10 @@ class TracezZPageHandlerTest {
assertThat(output.toString()).contains("<h2>Span Details</h2>");
assertThat(output.toString()).contains("<b> Span Name: " + RUNNING_SPAN + "</b>");
assertThat(output.toString()).contains("<b> Number of running: 1");
assertThat(output.toString()).contains(runningSpan.getContext().getTraceId().toLowerBase16());
assertThat(output.toString()).contains(runningSpan.getContext().getSpanId().toLowerBase16());
assertThat(output.toString())
.contains(runningSpan.getContext().getTraceIdAsHexString().toString());
assertThat(output.toString())
.contains(runningSpan.getContext().getSpanIdAsHexString().toString());
runningSpan.end();
}
@ -311,10 +313,14 @@ class TracezZPageHandlerTest {
assertThat(output.toString()).contains("<h2>Span Details</h2>");
assertThat(output.toString()).contains("<b> Span Name: " + LATENCY_SPAN + "</b>");
assertThat(output.toString()).contains("<b> Number of latency samples: 2");
assertThat(output.toString()).contains(latencySpan1.getContext().getTraceId().toLowerBase16());
assertThat(output.toString()).contains(latencySpan1.getContext().getSpanId().toLowerBase16());
assertThat(output.toString()).contains(latencySpan2.getContext().getTraceId().toLowerBase16());
assertThat(output.toString()).contains(latencySpan2.getContext().getSpanId().toLowerBase16());
assertThat(output.toString())
.contains(latencySpan1.getContext().getTraceIdAsHexString().toString());
assertThat(output.toString())
.contains(latencySpan1.getContext().getSpanIdAsHexString().toString());
assertThat(output.toString())
.contains(latencySpan2.getContext().getTraceIdAsHexString().toString());
assertThat(output.toString())
.contains(latencySpan2.getContext().getSpanIdAsHexString().toString());
}
@Test
@ -335,10 +341,14 @@ class TracezZPageHandlerTest {
assertThat(output.toString()).contains("<h2>Span Details</h2>");
assertThat(output.toString()).contains("<b> Span Name: " + ERROR_SPAN + "</b>");
assertThat(output.toString()).contains("<b> Number of error samples: 2");
assertThat(output.toString()).contains(errorSpan1.getContext().getTraceId().toLowerBase16());
assertThat(output.toString()).contains(errorSpan1.getContext().getSpanId().toLowerBase16());
assertThat(output.toString()).contains(errorSpan2.getContext().getTraceId().toLowerBase16());
assertThat(output.toString()).contains(errorSpan2.getContext().getSpanId().toLowerBase16());
assertThat(output.toString())
.contains(errorSpan1.getContext().getTraceIdAsHexString().toString());
assertThat(output.toString())
.contains(errorSpan1.getContext().getSpanIdAsHexString().toString());
assertThat(output.toString())
.contains(errorSpan2.getContext().getTraceIdAsHexString().toString());
assertThat(output.toString())
.contains(errorSpan2.getContext().getSpanIdAsHexString().toString());
}
@Test

7
testing_internal/src/main/java/io/opentelemetry/sdk/trace/TestSpanData.java
View File

@ -27,7 +27,6 @@ import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.SpanId;
import io.opentelemetry.trace.Status;
import io.opentelemetry.trace.TraceFlags;
import io.opentelemetry.trace.TraceId;
import io.opentelemetry.trace.TraceState;
import java.util.ArrayList;
import java.util.Collections;
@ -98,7 +97,7 @@ public abstract class TestSpanData implements SpanData {
* @param traceId the trace id.
* @return this builder (for chaining).
*/
public abstract Builder setTraceId(TraceId traceId);
public abstract Builder setTraceId(String traceId);
/**
* Set the span id on this builder.
@ -106,7 +105,7 @@ public abstract class TestSpanData implements SpanData {
* @param spanId the span id.
* @return this builder (for chaining).
*/
public abstract Builder setSpanId(SpanId spanId);
public abstract Builder setSpanId(String spanId);
/**
* Set the {@link TraceFlags} on this builder.
@ -131,7 +130,7 @@ public abstract class TestSpanData implements SpanData {
* @return this.
* @since 0.1.0
*/
public abstract Builder setParentSpanId(SpanId parentSpanId);
public abstract Builder setParentSpanId(String parentSpanId);
/**
* Set the {@link Resource} associated with this span. Must not be null.

6
testing_internal/src/test/java/io/opentelemetry/sdk/trace/TestSpanDataTest.java
View File

@ -43,7 +43,7 @@ class TestSpanDataTest {
void defaultValues() {
SpanData spanData = createBasicSpanBuilder().build();
assertThat(spanData.getParentSpanId().isValid()).isFalse();
assertThat(SpanId.isValid(spanData.getParentSpanId())).isFalse();
assertThat(spanData.getAttributes()).isEqualTo(Attributes.empty());
assertThat(spanData.getEvents()).isEqualTo(emptyList());
assertThat(spanData.getLinks()).isEqualTo(emptyList());
@ -106,8 +106,8 @@ class TestSpanDataTest {
private static SpanData createSpanDataWithMutableCollections() {
return createBasicSpanBuilder()
.setLinks(new ArrayList<Link>())
.setEvents(new ArrayList<SpanData.Event>())
.setLinks(new ArrayList<>())
.setEvents(new ArrayList<>())
.build();
}