Remove duplicative trace state passthrough methods

tracing/src/main/java/com/palantir/tracing/DeferredTracer.java

@@ -95,7 +95,7 @@ public DeferredTracer(@Safe String operation, @Safe Map<String, String> metadata
         Optional<Trace> maybeTrace = Tracer.copyTrace();
         if (maybeTrace.isPresent()) {
             Trace trace = maybeTrace.get();
-            this.traceState = trace.getTraceState();
+            this.traceState = trace.traceState();
             this.isObservable = trace.isObservable();
             this.parentSpanId = trace.top().map(OpenSpan::getSpanId).orElse(null);
             this.operation = operation;

tracing/src/main/java/com/palantir/tracing/InternalTracers.java

@@ -33,7 +33,7 @@ public static boolean isSampled(DetachedSpan detachedSpan) {
 
     /** Returns requestId of the provided detachedSpan. */
     public static Optional<String> getRequestId(DetachedSpan detachedSpan) {
-        return Optional.ofNullable(Tracer.getRequestId(detachedSpan));
+        return Tracer.getRequestId(detachedSpan);
     }
 
     /**

tracing/src/main/java/com/palantir/tracing/Trace.java

@@ -30,7 +30,6 @@
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.Optional;
-import org.jspecify.annotations.Nullable;
 
 /**
  * Represents a trace as an ordered list of non-completed spans. Supports adding and removing of spans. This class is
@@ -110,32 +109,8 @@ 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 traceState.traceId();
-    }
-
-    /**
-     * The request identifier of this trace, or null if undefined.
-     * <p>
-     * 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
-    final String maybeGetRequestId() {
-        return traceState.requestId();
-    }
-
-    /**
-     * The user agent propagated across this trace.
-     */
-    final Optional<String> getForUserAgent() {
-        return Optional.ofNullable(traceState.forUserAgent());
+    final TraceState traceState() {
+        return traceState;
     }
 
     /** Returns a copy of this Trace which can be independently mutated. */
@@ -202,12 +177,12 @@ boolean isObservable() {
 
         @Override
         Trace deepCopy() {
-            return new Sampled(new ArrayDeque<>(stack), getTraceState());
+            return new Sampled(new ArrayDeque<>(stack), traceState());
         }
 
         @Override
         public String toString() {
-            return "Trace{stack=" + stack + ", isObservable=true, state=" + getTraceState() + "}";
+            return "Trace{stack=" + stack + ", isObservable=true, state=" + traceState() + "}";
         }
     }
 
@@ -270,7 +245,7 @@ boolean isObservable() {
 
         @Override
         Trace deepCopy() {
-            return new Unsampled(numberOfSpans, getTraceState());
+            return new Unsampled(numberOfSpans, traceState());
         }
 
         /** Internal validation, this should never fail because {@link #pop()} only decrements positive values. */
@@ -283,7 +258,7 @@ private void validateNumberOfSpans() {
 
         @Override
         public String toString() {
-            return "Trace{numberOfSpans=" + numberOfSpans + ", isObservable=false, traceState=" + getTraceState() + "}";
+            return "Trace{numberOfSpans=" + numberOfSpans + ", isObservable=false, traceState=" + traceState() + "}";
         }
     }
 }

tracing/src/main/java/com/palantir/tracing/Tracer.java

@@ -117,9 +117,9 @@ public static Optional<TraceMetadata> maybeGetTraceMetadata() {
         OpenSpan span = trace.top().orElse(null);
 
         return Optional.of(TraceMetadata.builder()
-                .traceId(trace.getTraceState().traceId())
+                .traceId(trace.traceState().traceId())
                 .spanId(span != null ? span.getSpanId() : Tracers.randomId())
-                .requestId(Optional.ofNullable(trace.maybeGetRequestId()))
+                .requestId(Optional.ofNullable(trace.traceState().requestId()))
                 .build());
     }
 
@@ -327,9 +327,9 @@ static Detached detachInternal() {
             if (maybeOpenSpan == null) {
                 return NopDetached.INSTANCE;
             }
-            return new SampledDetached(trace.getTraceState(), maybeOpenSpan);
+            return new SampledDetached(trace.traceState(), maybeOpenSpan);
         } else {
-            return new UnsampledDetachedSpan(trace.getTraceState(), Optional.empty());
+            return new UnsampledDetachedSpan(trace.traceState(), Optional.empty());
         }
     }
 
@@ -351,12 +351,12 @@ static TraceState getTraceState() {
             return null;
         }
 
-        return maybeCurrentTrace.getTraceState();
+        return maybeCurrentTrace.traceState();
     }
 
     private static TraceState getTraceState(@Nullable Trace maybeCurrentTrace, SpanType newSpanType) {
         if (maybeCurrentTrace != null) {
-            return maybeCurrentTrace.getTraceState();
+            return maybeCurrentTrace.traceState();
         }
         return TraceState.of(Tracers.randomId(), getRequestIdForSpan(newSpanType), Optional.empty());
     }
@@ -368,13 +368,12 @@ private static Optional<String> getRequestIdForSpan(SpanType newSpanType) {
         return Optional.empty();
     }
 
-    @Nullable
-    static String getRequestId(DetachedSpan detachedSpan) {
+    static Optional<String> getRequestId(DetachedSpan detachedSpan) {
         if (detachedSpan instanceof SampledDetachedSpan sampledDetachedSpan) {
-            return sampledDetachedSpan.traceState.requestId();
+            return Optional.ofNullable(sampledDetachedSpan.traceState.requestId());
         }
         if (detachedSpan instanceof UnsampledDetachedSpan unsampledDetachedSpan) {
-            return unsampledDetachedSpan.traceState.requestId();
+            return Optional.ofNullable(unsampledDetachedSpan.traceState.requestId());
         }
         throw new SafeIllegalStateException("Unknown span type", SafeArg.of("detachedSpan", detachedSpan));
     }
@@ -598,7 +597,8 @@ public static <T> void fastCompleteSpan(TagTranslator<? super T> tag, T state) {
         if (trace != null) {
             Optional<OpenSpan> span = popCurrentSpan(trace);
             if (trace.isObservable()) {
-                completeSpanAndNotifyObservers(span, tag, state, trace.getTraceId());
+                completeSpanAndNotifyObservers(
+                        span, tag, state, trace.traceState().traceId());
             }
         } else {
             logCompletedWithoutStarted();
@@ -637,7 +637,11 @@ public static Optional<Span> completeSpan(@Safe Map<String, String> metadata) {
             return Optional.empty();
         }
         Optional<Span> maybeSpan = popCurrentSpan(trace)
-                .map(openSpan -> toSpan(openSpan, MapTagTranslator.INSTANCE, metadata, trace.getTraceId()));
+                .map(openSpan -> toSpan(
+                        openSpan,
+                        MapTagTranslator.INSTANCE,
+                        metadata,
+                        trace.traceState().traceId()));
 
         // Notify subscribers iff trace is observable
         if (maybeSpan.isPresent() && trace.isObservable()) {
@@ -772,15 +776,21 @@ public static boolean hasTraceId() {
      * Returns the globally unique identifier for this thread's trace.
      */
     public static String getTraceId() {
-        return checkNotNull(currentTrace.get(), "There is no trace").getTraceId();
+        return checkNotNull(currentTrace.get(), "There is no trace")
+                .traceState()
+                .traceId();
     }
 
     /**
      * Returns the forUserAgent propagated inside the trace.
      */
     static Optional<String> getForUserAgent() {
         Trace trace = currentTrace.get();
-        return trace == null ? Optional.empty() : trace.getForUserAgent();
+        if (trace == null) {
+            return Optional.empty();
+        }
+
+        return Optional.ofNullable(trace.traceState().forUserAgent());
     }
 
     /**
@@ -852,9 +862,9 @@ static void setTrace(Trace trace) {
         currentTrace.set(trace);
 
         // Give log appenders access to the trace id and whether the trace is being sampled
-        MDC.put(Tracers.TRACE_ID_KEY, trace.getTraceId());
+        MDC.put(Tracers.TRACE_ID_KEY, trace.traceState().traceId());
         setTraceSampledMdcIfObservable(trace.isObservable());
-        setTraceRequestId(trace.maybeGetRequestId());
+        setTraceRequestId(trace.traceState().requestId());
     }
 
     private static void setTraceSampledMdcIfObservable(boolean observable) {

tracing/src/test/java/com/palantir/tracing/TraceTest.java

@@ -50,7 +50,7 @@ public void testToString_doesNotContainTraceLocals() {
         Trace trace = Trace.of(true, TraceState.of("traceId", Optional.empty(), Optional.empty()));
 
         TraceLocal<String> traceLocal = TraceLocal.of();
-        trace.getTraceState().getOrCreateTraceLocals().put(traceLocal, "secret-value");
+        trace.traceState().getOrCreateTraceLocals().put(traceLocal, "secret-value");
 
         assertThat(trace.toString()).doesNotContain("secret");
     }

tracing/src/test/java/com/palantir/tracing/TracerTest.java

@@ -356,7 +356,7 @@ public void testClearAndGetTraceClearsMdc() {
             assertThat(MDC.get(Tracers.TRACE_ID_KEY)).isEqualTo(startTrace);
 
             Trace oldTrace = Tracer.getAndClearTrace();
-            assertThat(oldTrace.getTraceId()).isEqualTo(startTrace);
+            assertThat(oldTrace.traceState().traceId()).isEqualTo(startTrace);
             assertThat(MDC.get(Tracers.TRACE_ID_KEY)).isNull(); // after clearing, it's empty
         } finally {
             Tracer.fastCompleteSpan();