diff --git a/.palantir/revapi.yml b/.palantir/revapi.yml index f1212ff3a..6b81480f0 100644 --- a/.palantir/revapi.yml +++ b/.palantir/revapi.yml @@ -57,3 +57,9 @@ acceptedBreaks: old: "method com.palantir.tracing.api.OpenSpan.Builder com.palantir.tracing.api.ImmutableOpenSpan.Builder::originatingSpanId(java.util.Optional)\ \ @ com.palantir.tracing.api.OpenSpan.Builder" justification: "Type is not meant for external creation" + "6.4.0": + com.palantir.tracing:tracing: + - code: "java.field.serialVersionUIDChanged" + old: "field com.palantir.tracing.DeferredTracer.serialVersionUID" + new: "field com.palantir.tracing.DeferredTracer.serialVersionUID" + justification: "Library versions are in usually in sync" diff --git a/tracing/src/main/java/com/palantir/tracing/DeferredTracer.java b/tracing/src/main/java/com/palantir/tracing/DeferredTracer.java index 44fdd65fa..3a42d51e6 100644 --- a/tracing/src/main/java/com/palantir/tracing/DeferredTracer.java +++ b/tracing/src/main/java/com/palantir/tracing/DeferredTracer.java @@ -53,12 +53,12 @@ */ public final class DeferredTracer implements Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 2L; private static final String DEFAULT_OPERATION = "DeferredTracer(unnamed operation)"; @Nullable - private final String traceId; + private final TraceState traceState; private final boolean isObservable; @@ -71,9 +71,6 @@ public final class DeferredTracer implements Serializable { @Nullable private final String parentSpanId; - @Nullable - private final transient String requestId; - /** * Deprecated. * @@ -98,15 +95,13 @@ public DeferredTracer(@Safe String operation, @Safe Map metadata Optional maybeTrace = Tracer.copyTrace(); if (maybeTrace.isPresent()) { Trace trace = maybeTrace.get(); - this.traceId = trace.getTraceId(); - this.requestId = trace.getRequestId().orElse(null); + this.traceState = trace.getTraceState(); this.isObservable = trace.isObservable(); this.parentSpanId = trace.top().map(OpenSpan::getSpanId).orElse(null); this.operation = operation; this.metadata = metadata; } else { - this.traceId = null; - this.requestId = null; + this.traceState = null; this.isObservable = false; this.parentSpanId = null; this.operation = null; @@ -128,13 +123,13 @@ public T withTrace(Tracers.ThrowingCallable inner @MustBeClosed @SuppressWarnings("NullAway") // either both operation & parentSpanId are nullable or neither are CloseableTrace withTrace() { - if (traceId == null) { + if (traceState == null) { return NopCloseableTrace.INSTANCE; } Optional originalTrace = Tracer.getAndClearTraceIfPresent(); - Tracer.setTrace(Trace.of(isObservable, traceId, Optional.ofNullable(requestId))); + Tracer.setTrace(Trace.of(isObservable, traceState)); if (parentSpanId != null) { Tracer.fastStartSpan(operation, parentSpanId, SpanType.LOCAL); } else { diff --git a/tracing/src/main/java/com/palantir/tracing/InternalTracers.java b/tracing/src/main/java/com/palantir/tracing/InternalTracers.java index 20de7a4d0..ec4a1dced 100644 --- a/tracing/src/main/java/com/palantir/tracing/InternalTracers.java +++ b/tracing/src/main/java/com/palantir/tracing/InternalTracers.java @@ -33,7 +33,7 @@ public static boolean isSampled(DetachedSpan detachedSpan) { /** Returns true if the provided detachedSpan is sampled. */ public static Optional getRequestId(DetachedSpan detachedSpan) { - return Tracer.getRequestId(detachedSpan); + return Optional.ofNullable(Tracer.getRequestId(detachedSpan)); } private InternalTracers() {} diff --git a/tracing/src/main/java/com/palantir/tracing/Trace.java b/tracing/src/main/java/com/palantir/tracing/Trace.java index 7ffbb3fad..9fbb88622 100644 --- a/tracing/src/main/java/com/palantir/tracing/Trace.java +++ b/tracing/src/main/java/com/palantir/tracing/Trace.java @@ -44,14 +44,11 @@ */ public abstract class Trace { - private final String traceId; + private final TraceState traceState; - private final Optional requestId; - - private Trace(String traceId, Optional requestId) { - checkArgument(!Strings.isNullOrEmpty(traceId), "traceId must be non-empty"); - this.traceId = traceId; - this.requestId = checkNotNull(requestId, "requestId"); + private Trace(TraceState traceState) { + checkNotNull(traceState, "Trace state must not be null"); + this.traceState = traceState; } /** @@ -111,9 +108,14 @@ final OpenSpan startSpan(String operation, SpanType type) { */ abstract boolean isObservable(); + /** The state of the trace which is stored for each created trace. */ + final TraceState getTraceState() { + return this.traceState; + } + /** The globally unique non-empty identifier for this call trace. */ final String getTraceId() { - return traceId; + return traceState.traceId(); } /** @@ -124,27 +126,32 @@ final String getTraceId() { * distinguish between requests with the same traceId. */ final Optional getRequestId() { - return requestId; + return Optional.ofNullable(traceState.requestId()); } /** Returns a copy of this Trace which can be independently mutated. */ abstract Trace deepCopy(); + @Deprecated static Trace of(boolean isObservable, String traceId, Optional requestId) { - return isObservable ? new Sampled(traceId, requestId) : new Unsampled(traceId, requestId); + return of(isObservable, TraceState.of(traceId, requestId)); + } + + static Trace of(boolean isObservable, TraceState traceState) { + return isObservable ? new Sampled(traceState) : new Unsampled(traceState); } private static final class Sampled extends Trace { private final Deque stack; - private Sampled(ArrayDeque stack, String traceId, Optional requestId) { - super(traceId, requestId); + private Sampled(ArrayDeque stack, TraceState traceState) { + super(traceState); this.stack = stack; } - private Sampled(String traceId, Optional requestId) { - this(new ArrayDeque<>(), traceId, requestId); + private Sampled(TraceState traceState) { + this(new ArrayDeque<>(), traceState); } @Override @@ -186,12 +193,12 @@ boolean isObservable() { @Override Trace deepCopy() { - return new Sampled(new ArrayDeque<>(stack), getTraceId(), getRequestId()); + return new Sampled(new ArrayDeque<>(stack), getTraceState()); } @Override public String toString() { - return "Trace{stack=" + stack + ", isObservable=true, traceId='" + getTraceId() + "'}"; + return "Trace{stack=" + stack + ", isObservable=true, state=" + getTraceState() + "}"; } } @@ -202,14 +209,14 @@ private static final class Unsampled extends Trace { */ private int numberOfSpans; - private Unsampled(int numberOfSpans, String traceId, Optional requestId) { - super(traceId, requestId); + private Unsampled(int numberOfSpans, TraceState traceState) { + super(traceState); this.numberOfSpans = numberOfSpans; validateNumberOfSpans(); } - private Unsampled(String traceId, Optional requestId) { - this(0, traceId, requestId); + private Unsampled(TraceState traceState) { + this(0, traceState); } @Override @@ -254,7 +261,7 @@ boolean isObservable() { @Override Trace deepCopy() { - return new Unsampled(numberOfSpans, getTraceId(), getRequestId()); + return new Unsampled(numberOfSpans, getTraceState()); } /** Internal validation, this should never fail because {@link #pop()} only decrements positive values. */ @@ -267,8 +274,7 @@ private void validateNumberOfSpans() { @Override public String toString() { - return "Trace{numberOfSpans=" + numberOfSpans + ", isObservable=false, traceId='" + getTraceId() - + "', requestId='" + getRequestId().orElse(null) + "'}"; + return "Trace{numberOfSpans=" + numberOfSpans + ", isObservable=false, traceState=" + getTraceState() + "}"; } } } diff --git a/tracing/src/main/java/com/palantir/tracing/TraceState.java b/tracing/src/main/java/com/palantir/tracing/TraceState.java new file mode 100644 index 000000000..9f39885a4 --- /dev/null +++ b/tracing/src/main/java/com/palantir/tracing/TraceState.java @@ -0,0 +1,73 @@ +/* + * (c) Copyright 2021 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.tracing; + +import static com.palantir.logsafe.Preconditions.checkArgument; +import static com.palantir.logsafe.Preconditions.checkNotNull; + +import com.google.common.base.Strings; +import java.io.Serializable; +import java.util.Optional; +import javax.annotation.Nullable; + +/** + * Class representing the state which is created for each {@link Trace}. Contains the globally non-unique identifier of + * a trace and a request identifier used to identify different requests sent from the same trace. + */ +final class TraceState implements Serializable { + private static final long serialVersionUID = 1L; + + private final String traceId; + + @Nullable + private final String requestId; + + static TraceState of(String traceId, Optional requestId) { + checkArgument(!Strings.isNullOrEmpty(traceId), "traceId must be non-empty"); + checkNotNull(requestId, "requestId should be not-null"); + return new TraceState(traceId, requestId.orElse(null)); + } + + private TraceState(String traceId, @Nullable String requestId) { + this.traceId = traceId; + this.requestId = requestId; + } + + /** + * The globally unique non-empty identifier for this call trace. + * */ + String traceId() { + return traceId; + } + + /** + * The request identifier of this trace. + * + * The request identifier is an implementation detail of this tracing library. A new identifier is generated + * each time a new trace is created with a SERVER_INCOMING root span. This is a convenience in order to + * distinguish between requests with the same traceId. + */ + @Nullable + String requestId() { + return requestId; + } + + @Override + public String toString() { + return "TraceState{traceId='" + traceId + "', requestId='" + requestId + "'}"; + } +} diff --git a/tracing/src/main/java/com/palantir/tracing/Tracer.java b/tracing/src/main/java/com/palantir/tracing/Tracer.java index 6b1722bfa..428908424 100644 --- a/tracing/src/main/java/com/palantir/tracing/Tracer.java +++ b/tracing/src/main/java/com/palantir/tracing/Tracer.java @@ -74,7 +74,7 @@ private Tracer() {} private static Trace createTrace(Observability observability, String traceId, Optional requestId) { checkArgument(!Strings.isNullOrEmpty(traceId), "traceId must be non-empty"); boolean observable = shouldObserve(observability); - return Trace.of(observable, traceId, requestId); + return Trace.of(observable, TraceState.of(traceId, requestId)); } private static boolean shouldObserve(Observability observability) { @@ -113,19 +113,21 @@ public static Optional maybeGetTraceMetadata() { return Optional.empty(); } + String traceId = trace.getTraceId(); + Optional requestId = trace.getRequestId(); if (trace.isObservable()) { return trace.top().map(openSpan -> TraceMetadata.builder() .spanId(openSpan.getSpanId()) .parentSpanId(openSpan.getParentSpanId()) - .traceId(trace.getTraceId()) - .requestId(trace.getRequestId()) + .traceId(traceId) + .requestId(requestId) .build()); } else { return Optional.of(TraceMetadata.builder() .spanId(Tracers.randomId()) .parentSpanId(Optional.empty()) - .traceId(trace.getTraceId()) - .requestId(trace.getRequestId()) + .traceId(traceId) + .requestId(requestId) .build()); } } @@ -235,13 +237,12 @@ public static void fastStartSpan(@Safe String operation) { */ static DetachedSpan detachInternal(@Safe String operation, SpanType type) { Trace maybeCurrentTrace = currentTrace.get(); - String traceId = maybeCurrentTrace != null ? maybeCurrentTrace.getTraceId() : Tracers.randomId(); + TraceState traceState = getTraceState(maybeCurrentTrace, type); boolean sampled = maybeCurrentTrace != null ? maybeCurrentTrace.isObservable() : sampler.sample(); Optional parentSpan = getParentSpanId(maybeCurrentTrace); - Optional requestId = getRequestId(maybeCurrentTrace, type); return sampled - ? new SampledDetachedSpan(operation, type, traceId, requestId, parentSpan) - : new UnsampledDetachedSpan(traceId, requestId, Optional.empty()); + ? new SampledDetachedSpan(operation, type, traceState, parentSpan) + : new UnsampledDetachedSpan(traceState, Optional.empty()); } /** @@ -272,9 +273,10 @@ static DetachedSpan detachInternal( SpanType type) { // The current trace has no impact on this function, a new trace is spawned and existing thread state // is not modified. + TraceState traceState = TraceState.of(traceId, requestId); return shouldObserve(observability) - ? new SampledDetachedSpan(operation, type, traceId, requestId, parentSpanId) - : new UnsampledDetachedSpan(traceId, requestId, parentSpanId); + ? new SampledDetachedSpan(operation, type, traceState, parentSpanId) + : new UnsampledDetachedSpan(traceState, parentSpanId); } /** @@ -287,16 +289,14 @@ static Detached detachInternal() { return NopDetached.INSTANCE; } - String traceId = trace.getTraceId(); - Optional requestId = trace.getRequestId(); if (trace.isObservable()) { OpenSpan maybeOpenSpan = trace.top().orElse(null); if (maybeOpenSpan == null) { return NopDetached.INSTANCE; } - return new SampledDetached(traceId, requestId, maybeOpenSpan); + return new SampledDetached(trace.getTraceState(), maybeOpenSpan); } else { - return new UnsampledDetachedSpan(traceId, requestId, Optional.empty()); + return new UnsampledDetachedSpan(trace.getTraceState(), Optional.empty()); } } @@ -310,22 +310,27 @@ private static Optional getParentSpanId(@Nullable Trace trace) { return Optional.empty(); } - private static Optional getRequestId(@Nullable Trace maybeCurrentTrace, SpanType newSpanType) { + private static TraceState getTraceState(@Nullable Trace maybeCurrentTrace, SpanType newSpanType) { if (maybeCurrentTrace != null) { - return maybeCurrentTrace.getRequestId(); + return maybeCurrentTrace.getTraceState(); } + return TraceState.of(Tracers.randomId(), getRequestIdForSpan(newSpanType)); + } + + private static Optional getRequestIdForSpan(SpanType newSpanType) { if (newSpanType == SpanType.SERVER_INCOMING) { return Optional.of(Tracers.randomId()); } return Optional.empty(); } - static Optional getRequestId(DetachedSpan detachedSpan) { + @Nullable + static String getRequestId(DetachedSpan detachedSpan) { if (detachedSpan instanceof SampledDetachedSpan) { - return ((SampledDetachedSpan) detachedSpan).requestId; + return ((SampledDetachedSpan) detachedSpan).traceState.requestId(); } if (detachedSpan instanceof UnsampledDetachedSpan) { - return ((UnsampledDetachedSpan) detachedSpan).requestId; + return ((UnsampledDetachedSpan) detachedSpan).traceState.requestId(); } throw new SafeIllegalStateException("Unknown span type", SafeArg.of("detachedSpan", detachedSpan)); } @@ -372,36 +377,28 @@ private static final class SampledDetachedSpan implements DetachedSpan { private static final AtomicIntegerFieldUpdater completedUpdater = AtomicIntegerFieldUpdater.newUpdater(SampledDetachedSpan.class, "completed"); - private final String traceId; - private final Optional requestId; + private final TraceState traceState; private final OpenSpan openSpan; private volatile int completed; @SuppressWarnings("ImmutablesBuilderMissingInitialization") // OpenSpan#builder sets these - SampledDetachedSpan( - String operation, - SpanType type, - String traceId, - Optional requestId, - Optional parentSpanId) { - this.traceId = traceId; - this.requestId = requestId; + SampledDetachedSpan(String operation, SpanType type, TraceState traceState, Optional parentSpanId) { + this.traceState = traceState; this.openSpan = OpenSpan.of(operation, Tracers.randomId(), type, parentSpanId); } @MustBeClosed private static CloseableSpan childSpan( - String traceId, + TraceState traceState, OpenSpan openSpan, - Optional requestId, String operationName, TagTranslator translator, T data, SpanType type) { Trace maybeCurrentTrace = currentTrace.get(); - setTrace(Trace.of(true, traceId, requestId)); + setTrace(Trace.of(true, traceState)); Tracer.fastStartSpan(operationName, openSpan.getSpanId(), type); return TraceRestoringCloseableSpanWithMetadata.of(maybeCurrentTrace, translator, data); } @@ -410,18 +407,18 @@ private static CloseableSpan childSpan( @MustBeClosed public CloseableSpan childSpan( String operationName, TagTranslator translator, T data, SpanType type) { - return childSpan(traceId, openSpan, requestId, operationName, translator, data, type); + return childSpan(traceState, openSpan, operationName, translator, data, type); } @Override public DetachedSpan childDetachedSpan(String operation, SpanType type) { - return new SampledDetachedSpan(operation, type, traceId, requestId, Optional.of(openSpan.getSpanId())); + return new SampledDetachedSpan(operation, type, traceState, Optional.of(openSpan.getSpanId())); } @MustBeClosed - private static CloseableSpan attach(String traceId, OpenSpan openSpan, Optional requestId) { + private static CloseableSpan attach(OpenSpan openSpan, TraceState traceState) { Trace maybeCurrentTrace = currentTrace.get(); - Trace newTrace = Trace.of(true, traceId, requestId); + Trace newTrace = Trace.of(true, traceState); // Push the DetachedSpan OpenSpan to provide the correct parent information // to child spans created within the context of this attach. // It is VITAL that this span is never completed, it exists only for attribution. @@ -435,7 +432,7 @@ private static CloseableSpan attach(String traceId, OpenSpan openSpan, Optional< @Override @MustBeClosed public CloseableSpan attach() { - return attach(traceId, openSpan, requestId); + return attach(openSpan, traceState); } @Override @@ -446,7 +443,7 @@ public void complete() { @Override public void complete(TagTranslator tagTranslator, T data) { if (NOT_COMPLETE == completedUpdater.getAndSet(this, COMPLETE)) { - Tracer.notifyObservers(toSpan(openSpan, tagTranslator, data, traceId)); + Tracer.notifyObservers(toSpan(openSpan, tagTranslator, data, traceState.traceId())); } } @@ -454,12 +451,8 @@ public void complete(TagTranslator tagTranslator, T data) { public String toString() { return "SampledDetachedSpan{completed=" + (completed == COMPLETE) - + ", traceId='" - + traceId - + '\'' - + ", requestId='" - + requestId.orElse(null) - + '\'' + + ", traceState=" + + traceState + ", openSpan=" + openSpan + '}'; @@ -468,13 +461,11 @@ public String toString() { private static final class SampledDetached implements Detached { - private final String traceId; - private final Optional requestId; + private final TraceState traceState; private final OpenSpan openSpan; - SampledDetached(String traceId, Optional requestId, OpenSpan openSpan) { - this.traceId = traceId; - this.requestId = requestId; + SampledDetached(TraceState traceState, OpenSpan openSpan) { + this.traceState = traceState; this.openSpan = openSpan; } @@ -482,43 +473,33 @@ private static final class SampledDetached implements Detached { @MustBeClosed public CloseableSpan childSpan( String operationName, TagTranslator translator, T data, SpanType type) { - return SampledDetachedSpan.childSpan(traceId, openSpan, requestId, operationName, translator, data, type); + return SampledDetachedSpan.childSpan(traceState, openSpan, operationName, translator, data, type); } @Override public DetachedSpan childDetachedSpan(String operation, SpanType type) { - return new SampledDetachedSpan(operation, type, traceId, requestId, Optional.of(openSpan.getSpanId())); + return new SampledDetachedSpan(operation, type, traceState, Optional.of(openSpan.getSpanId())); } @Override @MustBeClosed public CloseableSpan attach() { - return SampledDetachedSpan.attach(traceId, openSpan, requestId); + return SampledDetachedSpan.attach(openSpan, traceState); } @Override public String toString() { - return "SampledDetached{traceId='" - + traceId - + '\'' - + ", requestId='" - + requestId.orElse(null) - + '\'' - + ", openSpan=" - + openSpan - + '}'; + return "SampledDetached{traceState=" + traceState + ", openSpan=" + openSpan + '}'; } } private static final class UnsampledDetachedSpan implements DetachedSpan { - private final String traceId; - private final Optional requestId; + private final TraceState traceState; private final Optional parentSpanId; - UnsampledDetachedSpan(String traceId, Optional requestId, Optional parentSpanId) { - this.traceId = traceId; - this.requestId = requestId; + UnsampledDetachedSpan(TraceState traceState, Optional parentSpanId) { + this.traceState = traceState; this.parentSpanId = parentSpanId; } @@ -526,7 +507,7 @@ private static final class UnsampledDetachedSpan implements DetachedSpan { public CloseableSpan childSpan( String operationName, TagTranslator _translator, T _data, SpanType type) { Trace maybeCurrentTrace = currentTrace.get(); - setTrace(Trace.of(false, traceId, requestId)); + setTrace(Trace.of(false, traceState)); if (parentSpanId.isPresent()) { Tracer.fastStartSpan(operationName, parentSpanId.get(), type); } else { @@ -562,7 +543,7 @@ public void complete(TagTranslator _tag, T _state) { @Override public String toString() { - return "UnsampledDetachedSpan{traceId='" + traceId + "', requestId='" + requestId.orElse(null) + "'}"; + return "UnsampledDetachedSpan{traceState=" + traceState + '}'; } } diff --git a/tracing/src/test/java/com/palantir/tracing/TraceTest.java b/tracing/src/test/java/com/palantir/tracing/TraceTest.java index 5e67e5d29..0f3059082 100644 --- a/tracing/src/test/java/com/palantir/tracing/TraceTest.java +++ b/tracing/src/test/java/com/palantir/tracing/TraceTest.java @@ -28,15 +28,19 @@ public final class TraceTest { @Test public void constructTrace_emptyTraceId() { - assertThatThrownBy(() -> Trace.of(false, "", Optional.empty())).isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Trace.of(false, TraceState.of("", Optional.empty()))) + .isInstanceOf(IllegalArgumentException.class); } @Test public void testToString() { - Trace trace = Trace.of(true, "traceId", Optional.empty()); + Trace trace = Trace.of(true, TraceState.of("traceId", Optional.empty())); OpenSpan span = trace.startSpan("operation", SpanType.LOCAL); assertThat(trace.toString()) - .isEqualTo("Trace{stack=[" + span + "], isObservable=true, traceId='traceId'}") + .isEqualTo("Trace{" + + "stack=[" + span + "], " + + "isObservable=true, " + + "state=TraceState{traceId='traceId', requestId='null'}}") .contains(span.getOperation()) .contains(span.getSpanId()); } diff --git a/tracing/src/test/java/com/palantir/tracing/TracerTest.java b/tracing/src/test/java/com/palantir/tracing/TracerTest.java index 7a38d25fa..80acb3a1b 100644 --- a/tracing/src/test/java/com/palantir/tracing/TracerTest.java +++ b/tracing/src/test/java/com/palantir/tracing/TracerTest.java @@ -146,14 +146,14 @@ public void testDoesNotNotifyObserversWhenCompletingNonexistingSpan() throws Exc public void testObserversAreInvokedOnObservableTracesOnly() throws Exception { Tracer.subscribe("1", observer1); - Tracer.setTrace(Trace.of(true, Tracers.randomId(), Optional.empty())); + Tracer.setTrace(Trace.of(true, TraceState.of(Tracers.randomId(), Optional.empty()))); Span span = startAndCompleteSpan(); verify(observer1).consume(span); span = startAndCompleteSpan(); verify(observer1).consume(span); verifyNoMoreInteractions(observer1); - Tracer.setTrace(Trace.of(false, Tracers.randomId(), Optional.empty())); + Tracer.setTrace(Trace.of(false, TraceState.of(Tracers.randomId(), Optional.empty()))); startAndFastCompleteSpan(); // not sampled, see above verifyNoMoreInteractions(observer1); } @@ -164,7 +164,7 @@ public void testCountsSpansWhenTraceIsNotObservable() throws Exception { assertThat(MDC.get(Tracers.TRACE_ID_KEY)).isNull(); assertThat(Tracer.hasTraceId()).isFalse(); assertThat(Tracer.hasUnobservableTrace()).isFalse(); - Tracer.setTrace(Trace.of(false, traceId, Optional.empty())); + Tracer.setTrace(Trace.of(false, TraceState.of(traceId, Optional.empty()))); // Unsampled trace should still apply thread state assertThat(MDC.get(Tracers.TRACE_ID_KEY)).isEqualTo(traceId); assertThat(Tracer.hasTraceId()).isTrue(); @@ -218,7 +218,7 @@ public void testTraceCopyIsIndependent() throws Exception { @Test public void testSetTraceSetsCurrentTraceAndMdcTraceIdKey() throws Exception { Tracer.fastStartSpan("operation"); - Tracer.setTrace(Trace.of(true, "newTraceId", Optional.empty())); + Tracer.setTrace(Trace.of(true, TraceState.of("newTraceId", Optional.empty()))); assertThat(Tracer.getTraceId()).isEqualTo("newTraceId"); assertThat(MDC.get(Tracers.TRACE_ID_KEY)).isEqualTo("newTraceId"); assertThat(Tracer.completeSpan()).isEmpty(); @@ -227,7 +227,7 @@ public void testSetTraceSetsCurrentTraceAndMdcTraceIdKey() throws Exception { @Test public void testSetTraceSetsMdcTraceSampledKeyWhenObserved() { - Tracer.setTrace(Trace.of(true, "observedTraceId", Optional.empty())); + Tracer.setTrace(Trace.of(true, TraceState.of("observedTraceId", Optional.empty()))); assertThat(MDC.get(Tracers.TRACE_SAMPLED_KEY)).isEqualTo("1"); assertThat(Tracer.completeSpan()).isEmpty(); assertThat(MDC.get(Tracers.TRACE_SAMPLED_KEY)).isNull(); @@ -235,7 +235,7 @@ public void testSetTraceSetsMdcTraceSampledKeyWhenObserved() { @Test public void testSetTraceMissingMdcTraceSampledKeyWhenNotObserved() { - Tracer.setTrace(Trace.of(false, "notObservedTraceId", Optional.empty())); + Tracer.setTrace(Trace.of(false, TraceState.of("notObservedTraceId", Optional.empty()))); assertThat(MDC.get(Tracers.TRACE_SAMPLED_KEY)).isNull(); assertThat(Tracer.completeSpan()).isEmpty(); assertThat(MDC.get(Tracers.TRACE_SAMPLED_KEY)).isNull(); @@ -336,7 +336,7 @@ public void testObserversThrow() { @Test public void testGetAndClearTraceIfPresent() { - Trace trace = Trace.of(true, "newTraceId", Optional.empty()); + Trace trace = Trace.of(true, TraceState.of("newTraceId", Optional.empty())); Tracer.setTrace(trace); Optional nonEmptyTrace = Tracer.getAndClearTraceIfPresent();