Remove trivial usage of fromLong[s] methods (#2730)

Signed-off-by: Bogdan Drutu <bogdandrutu@gmail.com>
2021-02-05 20:28:00 -08:00 · 2021-02-05 20:28:00 -08:00 · d932baa919
parent 7952823322
commit d932baa919
9 changed files with 73 additions and 85 deletions
--- a/exporters/jaeger-thrift/build.gradle
+++ b/exporters/jaeger-thrift/build.gradle
@ -16,7 +16,8 @@ dependencies {

    testImplementation 'com.fasterxml.jackson.core:jackson-databind',
            "org.testcontainers:junit-jupiter",
-            "com.squareup.okhttp3:okhttp"
-
+            "com.squareup.okhttp3:okhttp",
+            "com.google.guava:guava-testlib"
+    
    testImplementation project(':sdk:testing')
 }
--- a/exporters/jaeger-thrift/src/test/java/io/opentelemetry/exporter/jaeger/thrift/AdapterTest.java
+++ b/exporters/jaeger-thrift/src/test/java/io/opentelemetry/exporter/jaeger/thrift/AdapterTest.java
@ -16,17 +16,16 @@ import static io.opentelemetry.api.common.AttributeKey.stringKey;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static org.assertj.core.api.Assertions.assertThat;

+import com.google.common.io.BaseEncoding;
 import io.jaegertracing.thriftjava.Log;
 import io.jaegertracing.thriftjava.SpanRef;
 import io.jaegertracing.thriftjava.SpanRefType;
 import io.jaegertracing.thriftjava.Tag;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanContext;
-import io.opentelemetry.api.trace.SpanId;
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.api.trace.StatusCode;
 import io.opentelemetry.api.trace.TraceFlags;
-import io.opentelemetry.api.trace.TraceId;
 import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.sdk.resources.Resource;
 import io.opentelemetry.sdk.testing.trace.TestSpanData;
@ -34,6 +33,8 @@ import io.opentelemetry.sdk.trace.data.EventData;
 import io.opentelemetry.sdk.trace.data.LinkData;
 import io.opentelemetry.sdk.trace.data.SpanData;
 import io.opentelemetry.sdk.trace.data.StatusData;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@ -43,7 +44,7 @@ import org.junit.jupiter.api.Test;

 /** Unit tests for {@link Adapter}. */
 class AdapterTest {
-
+  private static final BaseEncoding hex = BaseEncoding.base16().lowerCase();
  private static final String LINK_TRACE_ID = "00000000000000000000000000cba123";
  private static final String LINK_SPAN_ID = "0000000000fed456";
  private static final String TRACE_ID = "00000000000000000000000000abc123";
@ -77,9 +78,9 @@ class AdapterTest {
    io.jaegertracing.thriftjava.Span jaegerSpan = Adapter.toJaeger(span);

    String rebuildTraceId =
-        TraceId.fromLongs(jaegerSpan.getTraceIdHigh(), jaegerSpan.getTraceIdLow());
+        traceIdFromLongs(jaegerSpan.getTraceIdHigh(), jaegerSpan.getTraceIdLow());
    assertThat(rebuildTraceId).isEqualTo(span.getTraceId());
-    assertThat(SpanId.fromLong(jaegerSpan.getSpanId())).isEqualTo(span.getSpanId());
+    assertThat(spanIdFromLong(jaegerSpan.getSpanId())).isEqualTo(span.getSpanId());
    assertThat(jaegerSpan.getOperationName()).isEqualTo("GET /api/endpoint");
    assertThat(jaegerSpan.getStartTime()).isEqualTo(MILLISECONDS.toMicros(startMs));
    assertThat(jaegerSpan.getDuration()).isEqualTo(MILLISECONDS.toMicros(duration));
@ -205,8 +206,8 @@ class AdapterTest {
    SpanRef spanRef = Adapter.toSpanRef(link);

    // verify
-    assertThat(SpanId.fromLong(spanRef.getSpanId())).isEqualTo(SPAN_ID);
-    assertThat(TraceId.fromLongs(spanRef.getTraceIdHigh(), spanRef.getTraceIdLow()))
+    assertThat(spanIdFromLong(spanRef.getSpanId())).isEqualTo(SPAN_ID);
+    assertThat(traceIdFromLongs(spanRef.getTraceIdHigh(), spanRef.getTraceIdLow()))
        .isEqualTo(TRACE_ID);
    assertThat(spanRef.getRefType()).isEqualTo(SpanRefType.FOLLOWS_FROM);
  }
@ -318,9 +319,9 @@ class AdapterTest {
    for (SpanRef spanRef : jaegerSpan.getReferences()) {

      if (SpanRefType.FOLLOWS_FROM.equals(spanRef.getRefType())) {
-        assertThat(TraceId.fromLongs(spanRef.getTraceIdHigh(), spanRef.getTraceIdLow()))
+        assertThat(traceIdFromLongs(spanRef.getTraceIdHigh(), spanRef.getTraceIdLow()))
            .isEqualTo(LINK_TRACE_ID);
-        assertThat(SpanId.fromLong(spanRef.getSpanId())).isEqualTo(LINK_SPAN_ID);
+        assertThat(spanIdFromLong(spanRef.getSpanId())).isEqualTo(LINK_SPAN_ID);
        found = true;
      }
    }
@ -331,12 +332,21 @@ class AdapterTest {
    boolean found = false;
    for (SpanRef spanRef : jaegerSpan.getReferences()) {
      if (SpanRefType.CHILD_OF.equals(spanRef.getRefType())) {
-        assertThat(TraceId.fromLongs(spanRef.getTraceIdHigh(), spanRef.getTraceIdLow()))
+        assertThat(traceIdFromLongs(spanRef.getTraceIdHigh(), spanRef.getTraceIdLow()))
            .isEqualTo(TRACE_ID);
-        assertThat(SpanId.fromLong(spanRef.getSpanId())).isEqualTo(PARENT_SPAN_ID);
+        assertThat(spanIdFromLong(spanRef.getSpanId())).isEqualTo(PARENT_SPAN_ID);
        found = true;
      }
    }
    assertThat(found).isTrue();
  }
+
+  private static String traceIdFromLongs(long high, long low) {
+    return hex.encode(
+        ByteBuffer.allocate(16).order(ByteOrder.BIG_ENDIAN).putLong(high).putLong(low).array());
+  }
+
+  private static String spanIdFromLong(long id) {
+    return hex.encode(ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN).putLong(id).array());
+  }
 }
--- a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingSpanExporterTest.java
+++ b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingSpanExporterTest.java
@ -13,10 +13,8 @@ import static org.assertj.core.api.Assertions.assertThat;
 import io.github.netmikey.logunit.api.LogCapturer;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanContext;
-import io.opentelemetry.api.trace.SpanId;
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.api.trace.TraceFlags;
-import io.opentelemetry.api.trace.TraceId;
 import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
 import io.opentelemetry.sdk.resources.Resource;
@ -43,8 +41,8 @@ class OtlpJsonLoggingSpanExporterTest {
          .setHasEnded(true)
          .setSpanContext(
              SpanContext.create(
-                  TraceId.fromLongs(1234L, 6789L),
-                  SpanId.fromLong(9876L),
+                  "12345678876543211234567887654321",
+                  "8765432112345678",
                  TraceFlags.getSampled(),
                  TraceState.getDefault()))
          .setStartEpochNanos(100)
@ -71,8 +69,8 @@ class OtlpJsonLoggingSpanExporterTest {
          .setHasEnded(false)
          .setSpanContext(
              SpanContext.create(
-                  TraceId.fromLongs(20L, 30L),
-                  SpanId.fromLong(15L),
+                  "12340000000043211234000000004321",
+                  "8765000000005678",
                  TraceFlags.getSampled(),
                  TraceState.getDefault()))
          .setStartEpochNanos(500)
@ -117,8 +115,8 @@ class OtlpJsonLoggingSpanExporterTest {
            + "      \"version\": \"2\""
            + "    },"
            + "    \"spans\": [{"
-            + "      \"traceId\": \"0000000000000014000000000000001e\","
-            + "      \"spanId\": \"000000000000000f\","
+            + "      \"traceId\": \"12340000000043211234000000004321\","
+            + "      \"spanId\": \"8765000000005678\","
            + "      \"name\": \"testSpan2\","
            + "      \"kind\": \"SPAN_KIND_CLIENT\","
            + "      \"startTimeUnixNano\": \"500\","
@ -134,8 +132,8 @@ class OtlpJsonLoggingSpanExporterTest {
            + "      \"version\": \"1\""
            + "    },"
            + "    \"spans\": [{"
-            + "      \"traceId\": \"00000000000004d20000000000001a85\","
-            + "      \"spanId\": \"0000000000002694\","
+            + "      \"traceId\": \"12345678876543211234567887654321\","
+            + "      \"spanId\": \"8765432112345678\","
            + "      \"name\": \"testSpan1\","
            + "      \"kind\": \"SPAN_KIND_INTERNAL\","
            + "      \"startTimeUnixNano\": \"100\","
--- a/exporters/logging/src/test/java/io/opentelemetry/exporter/logging/LoggingSpanExporterTest.java
+++ b/exporters/logging/src/test/java/io/opentelemetry/exporter/logging/LoggingSpanExporterTest.java
@ -14,10 +14,8 @@ import static org.assertj.core.api.Assertions.assertThat;
 import io.github.netmikey.logunit.api.LogCapturer;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanContext;
-import io.opentelemetry.api.trace.SpanId;
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.api.trace.TraceFlags;
-import io.opentelemetry.api.trace.TraceId;
 import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
@ -46,8 +44,8 @@ class LoggingSpanExporterTest {
          .setHasEnded(true)
          .setSpanContext(
              SpanContext.create(
-                  TraceId.fromLongs(1234L, 6789L),
-                  SpanId.fromLong(9876L),
+                  "12345678876543211234567887654321",
+                  "8765432112345678",
                  TraceFlags.getSampled(),
                  TraceState.getDefault()))
          .setStartEpochNanos(100)
@ -72,8 +70,8 @@ class LoggingSpanExporterTest {
          .setHasEnded(false)
          .setSpanContext(
              SpanContext.create(
-                  TraceId.fromLongs(20L, 30L),
-                  SpanId.fromLong(15L),
+                  "12340000000043211234000000004321",
+                  "8765000000005678",
                  TraceFlags.getSampled(),
                  TraceState.getDefault()))
          .setStartEpochNanos(500)
@ -108,12 +106,12 @@ class LoggingSpanExporterTest {
        .allSatisfy(log -> assertThat(log.getLevel()).isEqualTo(Level.INFO));
    assertThat(logs.getEvents().get(0).getMessage())
        .isEqualTo(
-            "'testSpan1' : 00000000000004d20000000000001a85 0000000000002694 "
+            "'testSpan1' : 12345678876543211234567887654321 8765432112345678 "
                + "INTERNAL [tracer: tracer1:] "
                + "{animal=\"cat\", lives=9}");
    assertThat(logs.getEvents().get(1).getMessage())
        .isEqualTo(
-            "'testSpan2' : 0000000000000014000000000000001e 000000000000000f "
+            "'testSpan2' : 12340000000043211234000000004321 8765000000005678 "
                + "CLIENT [tracer: tracer2:1.0] {}");
  }

@ -125,8 +123,8 @@ class LoggingSpanExporterTest {
            .setHasEnded(true)
            .setSpanContext(
                SpanContext.create(
-                    TraceId.fromLongs(1234L, 6789L),
-                    SpanId.fromLong(9876L),
+                    "12345678876543211234567887654321",
+                    "8765432112345678",
                    TraceFlags.getSampled(),
                    TraceState.getDefault()))
            .setStartEpochNanos(epochNanos)
--- a/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/JaegerPropagatorTest.java
+++ b/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/JaegerPropagatorTest.java
@ -40,15 +40,12 @@ 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 String TRACE_ID = TraceId.fromLongs(TRACE_ID_HI, TRACE_ID_LOW);
+  private static final String TRACE_ID = "000000000000004d0000000000000016";
  private static final long SHORT_TRACE_ID_HI = 0L;
  private static final long SHORT_TRACE_ID_LOW = 2322222L;
-  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 String SHORT_TRACE_ID = "00000000000000000000000000236f2e";
+  private static final String SPAN_ID = "0000000000017c29";
  private static final long SPAN_ID_LONG = 97321L;
-  private static final String SPAN_ID = SpanId.fromLong(SPAN_ID_LONG);
  private static final long DEPRECATED_PARENT_SPAN_LONG = 0L;
  private static final TextMapPropagator.Setter<Map<String, String>> setter = Map::put;
  private static final TextMapPropagator.Getter<Map<String, String>> getter =
@ -104,8 +101,7 @@ class JaegerPropagatorTest {
    assertThat(carrier)
        .containsEntry(
            PROPAGATION_HEADER,
-            generateTraceIdHeaderValue(
-                TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "1"));
+            generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "1"));
  }

  @Test
@ -122,8 +118,7 @@ class JaegerPropagatorTest {
    assertThat(carrier)
        .containsEntry(
            PROPAGATION_HEADER,
-            generateTraceIdHeaderValue(
-                TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "1"));
+            generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "1"));
  }

  @Test
@ -138,8 +133,7 @@ class JaegerPropagatorTest {
    assertThat(carrier)
        .containsEntry(
            PROPAGATION_HEADER,
-            generateTraceIdHeaderValue(
-                TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "0"));
+            generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "0"));
  }

  @Test
@ -157,8 +151,7 @@ class JaegerPropagatorTest {
    assertThat(carrier)
        .containsEntry(
            PROPAGATION_HEADER,
-            generateTraceIdHeaderValue(
-                TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "1"));
+            generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "1"));
    assertThat(carrier).containsEntry(BAGGAGE_PREFIX + "foo", "bar");
  }

@ -221,7 +214,7 @@ class JaegerPropagatorTest {
    invalidHeaders.put(
        PROPAGATION_HEADER,
        generateTraceIdHeaderValue(
-            "abcdefghijklmnopabcdefghijklmnop", SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "0"));
+            "abcdefghijklmnopabcdefghijklmnop", SPAN_ID, DEPRECATED_PARENT_SPAN, "0"));

    assertThat(getSpanContext(jaegerPropagator.extract(Context.current(), invalidHeaders, getter)))
        .isSameAs(SpanContext.getInvalid());
@ -232,8 +225,7 @@ class JaegerPropagatorTest {
    Map<String, String> invalidHeaders = new LinkedHashMap<>();
    invalidHeaders.put(
        PROPAGATION_HEADER,
-        generateTraceIdHeaderValue(
-            TRACE_ID_BASE16 + "00", SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "0"));
+        generateTraceIdHeaderValue(TRACE_ID + "00", SPAN_ID, DEPRECATED_PARENT_SPAN, "0"));

    assertThat(getSpanContext(jaegerPropagator.extract(Context.current(), invalidHeaders, getter)))
        .isSameAs(SpanContext.getInvalid());
@ -244,8 +236,7 @@ class JaegerPropagatorTest {
    Map<String, String> invalidHeaders = new LinkedHashMap<>();
    invalidHeaders.put(
        PROPAGATION_HEADER,
-        generateTraceIdHeaderValue(
-            TRACE_ID_BASE16, "abcdefghijklmnop", DEPRECATED_PARENT_SPAN, "0"));
+        generateTraceIdHeaderValue(TRACE_ID, "abcdefghijklmnop", DEPRECATED_PARENT_SPAN, "0"));

    assertThat(getSpanContext(jaegerPropagator.extract(Context.current(), invalidHeaders, getter)))
        .isSameAs(SpanContext.getInvalid());
@ -256,8 +247,7 @@ class JaegerPropagatorTest {
    Map<String, String> invalidHeaders = new LinkedHashMap<>();
    invalidHeaders.put(
        PROPAGATION_HEADER,
-        generateTraceIdHeaderValue(
-            TRACE_ID_BASE16, SPAN_ID_BASE16 + "00", DEPRECATED_PARENT_SPAN, "0"));
+        generateTraceIdHeaderValue(TRACE_ID, SPAN_ID + "00", DEPRECATED_PARENT_SPAN, "0"));

    assertThat(getSpanContext(jaegerPropagator.extract(Context.current(), invalidHeaders, getter)))
        .isSameAs(SpanContext.getInvalid());
@ -268,7 +258,7 @@ class JaegerPropagatorTest {
    Map<String, String> invalidHeaders = new LinkedHashMap<>();
    invalidHeaders.put(
        PROPAGATION_HEADER,
-        generateTraceIdHeaderValue(TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, ""));
+        generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, ""));

    assertThat(getSpanContext(jaegerPropagator.extract(Context.current(), invalidHeaders, getter)))
        .isSameAs(SpanContext.getInvalid());
@ -279,8 +269,7 @@ class JaegerPropagatorTest {
    Map<String, String> invalidHeaders = new LinkedHashMap<>();
    invalidHeaders.put(
        PROPAGATION_HEADER,
-        generateTraceIdHeaderValue(
-            TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "10220"));
+        generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "10220"));

    assertThat(getSpanContext(jaegerPropagator.extract(Context.current(), invalidHeaders, getter)))
        .isSameAs(SpanContext.getInvalid());
@ -291,8 +280,7 @@ class JaegerPropagatorTest {
    Map<String, String> invalidHeaders = new LinkedHashMap<>();
    invalidHeaders.put(
        PROPAGATION_HEADER,
-        generateTraceIdHeaderValue(
-            TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "abcdefr"));
+        generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "abcdefr"));

    assertThat(getSpanContext(jaegerPropagator.extract(Context.current(), invalidHeaders, getter)))
        .isSameAs(SpanContext.getInvalid());
--- a/sdk-extensions/jaeger-remote-sampler/src/test/java/io/opentelemetry/sdk/extension/trace/jaeger/sampler/RateLimitingSamplerTest.java
+++ b/sdk-extensions/jaeger-remote-sampler/src/test/java/io/opentelemetry/sdk/extension/trace/jaeger/sampler/RateLimitingSamplerTest.java
@ -10,10 +10,8 @@ import static org.assertj.core.api.Assertions.assertThat;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.api.trace.SpanContext;
-import io.opentelemetry.api.trace.SpanId;
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.api.trace.TraceFlags;
-import io.opentelemetry.api.trace.TraceId;
 import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.trace.samplers.SamplingDecision;
@ -25,20 +23,20 @@ class RateLimitingSamplerTest {

  private static final String SPAN_NAME = "MySpanName";
  private static final SpanKind SPAN_KIND = SpanKind.INTERNAL;
-  private final String traceId = TraceId.fromLongs(150, 150);
-  private final String parentSpanId = SpanId.fromLong(250);
-  private final Context sampledSpanContext =
+  private static final String TRACE_ID = "12345678876543211234567887654321";
+  private static final String PARENT_SPAN_ID = "8765432112345678";
+  private static final Context sampledSpanContext =
      Context.root()
          .with(
              Span.wrap(
                  SpanContext.create(
-                      traceId, parentSpanId, TraceFlags.getSampled(), TraceState.getDefault())));
-  private final Context notSampledSpanContext =
+                      TRACE_ID, PARENT_SPAN_ID, TraceFlags.getSampled(), TraceState.getDefault())));
+  private static final Context notSampledSpanContext =
      Context.root()
          .with(
              Span.wrap(
                  SpanContext.create(
-                      traceId, parentSpanId, TraceFlags.getDefault(), TraceState.getDefault())));
+                      TRACE_ID, PARENT_SPAN_ID, TraceFlags.getDefault(), TraceState.getDefault())));

  @Test
  void alwaysSampleSampledContext() {
@ -47,7 +45,7 @@ class RateLimitingSamplerTest {
            sampler
                .shouldSample(
                    sampledSpanContext,
-                    traceId,
+                    TRACE_ID,
                    SPAN_NAME,
                    SPAN_KIND,
                    Attributes.empty(),
@ -58,7 +56,7 @@ class RateLimitingSamplerTest {
            sampler
                .shouldSample(
                    sampledSpanContext,
-                    traceId,
+                    TRACE_ID,
                    SPAN_NAME,
                    SPAN_KIND,
                    Attributes.empty(),
@ -73,7 +71,7 @@ class RateLimitingSamplerTest {
    SamplingResult samplingResult =
        sampler.shouldSample(
            notSampledSpanContext,
-            traceId,
+            TRACE_ID,
            SPAN_NAME,
            SPAN_KIND,
            Attributes.empty(),
@ -83,7 +81,7 @@ class RateLimitingSamplerTest {
            sampler
                .shouldSample(
                    notSampledSpanContext,
-                    traceId,
+                    TRACE_ID,
                    SPAN_NAME,
                    SPAN_KIND,
                    Attributes.empty(),
--- a/sdk/testing/src/test/java/io/opentelemetry/sdk/testing/assertj/OpenTelemetryAssertionsTest.java
+++ b/sdk/testing/src/test/java/io/opentelemetry/sdk/testing/assertj/OpenTelemetryAssertionsTest.java
@ -11,10 +11,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanContext;
-import io.opentelemetry.api.trace.SpanId;
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.api.trace.TraceFlags;
-import io.opentelemetry.api.trace.TraceId;
 import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
 import io.opentelemetry.sdk.resources.Resource;
@ -31,9 +29,9 @@ import org.junit.jupiter.api.Test;

@SuppressWarnings("PreferJavaTimeOverload")
 class OpenTelemetryAssertionsTest {
-  private static final String TRACE_ID = TraceId.fromLongs(1, 2);
-  private static final String SPAN_ID1 = SpanId.fromLong(3);
-  private static final String SPAN_ID2 = SpanId.fromLong(4);
+  private static final String TRACE_ID = "00000000000000010000000000000002";
+  private static final String SPAN_ID1 = "0000000000000003";
+  private static final String SPAN_ID2 = "0000000000000004";
  private static final TraceState TRACE_STATE = TraceState.builder().set("cat", "meow").build();
  private static final Resource RESOURCE =
      Resource.create(Attributes.builder().put("dog", "bark").build());
--- a/sdk/trace/src/jmh/java/io/opentelemetry/sdk/trace/export/MultiSpanExporterBenchmark.java
+++ b/sdk/trace/src/jmh/java/io/opentelemetry/sdk/trace/export/MultiSpanExporterBenchmark.java
@ -6,10 +6,8 @@
 package io.opentelemetry.sdk.trace.export;

 import io.opentelemetry.api.trace.SpanContext;
-import io.opentelemetry.api.trace.SpanId;
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.api.trace.TraceFlags;
-import io.opentelemetry.api.trace.TraceId;
 import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import io.opentelemetry.sdk.testing.trace.TestSpanData;
@ -73,8 +71,8 @@ public class MultiSpanExporterBenchmark {
          TestSpanData.builder()
              .setSpanContext(
                  SpanContext.create(
-                      TraceId.fromLongs(1, 1),
-                      SpanId.fromLong(1),
+                      "12345678876543211234567887654321",
+                      "8765432112345678",
                      TraceFlags.getSampled(),
                      TraceState.getDefault()))
              .setName("noop")
--- a/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanBuilderTest.java
+++ b/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanBuilderTest.java
@ -26,7 +26,6 @@ import io.opentelemetry.api.trace.SpanId;
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.api.trace.StatusCode;
 import io.opentelemetry.api.trace.TraceFlags;
-import io.opentelemetry.api.trace.TraceId;
 import io.opentelemetry.api.trace.TraceState;
 import io.opentelemetry.api.trace.TracerProvider;
 import io.opentelemetry.context.Context;
@ -58,8 +57,8 @@ class SdkSpanBuilderTest {
  private static final String SPAN_NAME = "span_name";
  private final SpanContext sampledSpanContext =
      SpanContext.create(
-          TraceId.fromLongs(1000, 1000),
-          SpanId.fromLong(3000),
+          "12345678876543211234567887654321",
+          "8765432112345678",
          TraceFlags.getSampled(),
          TraceState.getDefault());

@ -162,8 +161,8 @@ class SdkSpanBuilderTest {
      // this test to pass.
      spanBuilder.addLink(
          SpanContext.create(
-              TraceId.fromLongs(2000, 2000),
-              SpanId.fromLong(4000),
+              "00000000000004d20000000000001a85",
+              "0000000000002694",
              TraceFlags.getSampled(),
              TraceState.getDefault()));
      assertThat(span.toSpanData().getLinks())