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

Signed-off-by: Bogdan Drutu <bogdandrutu@gmail.com>

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')
 }

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(spanIdFromLong(spanRef.getSpanId())).isEqualTo(SPAN_ID);
-    assertThat(TraceId.fromLongs(spanRef.getTraceIdHigh(), spanRef.getTraceIdLow()))
+    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());
+  }
 }

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),
+                  "12345678876543211234567887654321",
-                  SpanId.fromLong(9876L),
+                  "8765432112345678",
                   TraceFlags.getSampled(),
                   TraceState.getDefault()))
           .setStartEpochNanos(100)
@@ -71,8 +69,8 @@ class OtlpJsonLoggingSpanExporterTest {
           .setHasEnded(false)
           .setSpanContext(
               SpanContext.create(
-                  TraceId.fromLongs(20L, 30L),
+                  "12340000000043211234000000004321",
-                  SpanId.fromLong(15L),
+                  "8765000000005678",
                   TraceFlags.getSampled(),
                   TraceState.getDefault()))
           .setStartEpochNanos(500)
@@ -117,8 +115,8 @@ class OtlpJsonLoggingSpanExporterTest {
             + "      \"version\": \"2\""
             + "    },"
             + "    \"spans\": [{"
-            + "      \"traceId\": \"0000000000000014000000000000001e\","
+            + "      \"traceId\": \"12340000000043211234000000004321\","
-            + "      \"spanId\": \"000000000000000f\","
+            + "      \"spanId\": \"8765000000005678\","
             + "      \"name\": \"testSpan2\","
             + "      \"kind\": \"SPAN_KIND_CLIENT\","
             + "      \"startTimeUnixNano\": \"500\","
@@ -134,8 +132,8 @@ class OtlpJsonLoggingSpanExporterTest {
             + "      \"version\": \"1\""
             + "    },"
             + "    \"spans\": [{"
-            + "      \"traceId\": \"00000000000004d20000000000001a85\","
+            + "      \"traceId\": \"12345678876543211234567887654321\","
-            + "      \"spanId\": \"0000000000002694\","
+            + "      \"spanId\": \"8765432112345678\","
             + "      \"name\": \"testSpan1\","
             + "      \"kind\": \"SPAN_KIND_INTERNAL\","
             + "      \"startTimeUnixNano\": \"100\","

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),
+                  "12345678876543211234567887654321",
-                  SpanId.fromLong(9876L),
+                  "8765432112345678",
                   TraceFlags.getSampled(),
                   TraceState.getDefault()))
           .setStartEpochNanos(100)
@@ -72,8 +70,8 @@ class LoggingSpanExporterTest {
           .setHasEnded(false)
           .setSpanContext(
               SpanContext.create(
-                  TraceId.fromLongs(20L, 30L),
+                  "12340000000043211234000000004321",
-                  SpanId.fromLong(15L),
+                  "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),
+                    "12345678876543211234567887654321",
-                    SpanId.fromLong(9876L),
+                    "8765432112345678",
                     TraceFlags.getSampled(),
                     TraceState.getDefault()))
             .setStartEpochNanos(epochNanos)

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 = "000000000000004d0000000000000016";
-  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 String SHORT_TRACE_ID =
+  private static final String SHORT_TRACE_ID = "00000000000000000000000000236f2e";
-      TraceId.fromLongs(SHORT_TRACE_ID_HI, SHORT_TRACE_ID_LOW);
+  private static final String SPAN_ID = "0000000000017c29";
-  private static final String SPAN_ID_BASE16 = "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(
+            generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "1"));
-                TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "1"));
   }
 
   @Test
@@ -122,8 +118,7 @@ class JaegerPropagatorTest {
     assertThat(carrier)
         .containsEntry(
             PROPAGATION_HEADER,
-            generateTraceIdHeaderValue(
+            generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "1"));
-                TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "1"));
   }
 
   @Test
@@ -138,8 +133,7 @@ class JaegerPropagatorTest {
     assertThat(carrier)
         .containsEntry(
             PROPAGATION_HEADER,
-            generateTraceIdHeaderValue(
+            generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "0"));
-                TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "0"));
   }
 
   @Test
@@ -157,8 +151,7 @@ class JaegerPropagatorTest {
     assertThat(carrier)
         .containsEntry(
             PROPAGATION_HEADER,
-            generateTraceIdHeaderValue(
+            generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "1"));
-                TRACE_ID_BASE16, SPAN_ID_BASE16, 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(
+        generateTraceIdHeaderValue(TRACE_ID + "00", SPAN_ID, DEPRECATED_PARENT_SPAN, "0"));
-            TRACE_ID_BASE16 + "00", SPAN_ID_BASE16, 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(
+        generateTraceIdHeaderValue(TRACE_ID, "abcdefghijklmnop", DEPRECATED_PARENT_SPAN, "0"));
-            TRACE_ID_BASE16, "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(
+        generateTraceIdHeaderValue(TRACE_ID, SPAN_ID + "00", DEPRECATED_PARENT_SPAN, "0"));
-            TRACE_ID_BASE16, SPAN_ID_BASE16 + "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(
+        generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "10220"));
-            TRACE_ID_BASE16, SPAN_ID_BASE16, 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(
+        generateTraceIdHeaderValue(TRACE_ID, SPAN_ID, DEPRECATED_PARENT_SPAN, "abcdefr"));
-            TRACE_ID_BASE16, SPAN_ID_BASE16, DEPRECATED_PARENT_SPAN, "abcdefr"));
 
     assertThat(getSpanContext(jaegerPropagator.extract(Context.current(), invalidHeaders, getter)))
         .isSameAs(SpanContext.getInvalid());

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 static final String TRACE_ID = "12345678876543211234567887654321";
-  private final String parentSpanId = SpanId.fromLong(250);
+  private static final String PARENT_SPAN_ID = "8765432112345678";
-  private final Context sampledSpanContext =
+  private static final Context sampledSpanContext =
       Context.root()
           .with(
               Span.wrap(
                   SpanContext.create(
-                      traceId, parentSpanId, TraceFlags.getSampled(), TraceState.getDefault())));
+                      TRACE_ID, PARENT_SPAN_ID, TraceFlags.getSampled(), TraceState.getDefault())));
-  private final Context notSampledSpanContext =
+  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(),

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 TRACE_ID = "00000000000000010000000000000002";
-  private static final String SPAN_ID1 = SpanId.fromLong(3);
+  private static final String SPAN_ID1 = "0000000000000003";
-  private static final String SPAN_ID2 = SpanId.fromLong(4);
+  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());

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),
+                      "12345678876543211234567887654321",
-                      SpanId.fromLong(1),
+                      "8765432112345678",
                       TraceFlags.getSampled(),
                       TraceState.getDefault()))
               .setName("noop")

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