From d932baa9197b6642e7133031a73530db2bb3da30 Mon Sep 17 00:00:00 2001 From: Bogdan Drutu Date: Fri, 5 Feb 2021 20:28:00 -0800 Subject: [PATCH] Remove trivial usage of fromLong[s] methods (#2730) Signed-off-by: Bogdan Drutu --- exporters/jaeger-thrift/build.gradle | 5 ++- .../exporter/jaeger/thrift/AdapterTest.java | 32 ++++++++++----- .../otlp/OtlpJsonLoggingSpanExporterTest.java | 18 ++++----- .../logging/LoggingSpanExporterTest.java | 18 ++++----- .../propagation/JaegerPropagatorTest.java | 40 +++++++------------ .../sampler/RateLimitingSamplerTest.java | 22 +++++----- .../assertj/OpenTelemetryAssertionsTest.java | 8 ++-- .../export/MultiSpanExporterBenchmark.java | 6 +-- .../sdk/trace/SdkSpanBuilderTest.java | 9 ++--- 9 files changed, 73 insertions(+), 85 deletions(-) diff --git a/exporters/jaeger-thrift/build.gradle b/exporters/jaeger-thrift/build.gradle index 2d3cdad91c..105d129a02 100644 --- 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') } diff --git 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 index 64a0b0f63a..cbbd6f133d 100644 --- 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()); + } } diff --git 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 index 70fdb16886..d937ccc6df 100644 --- 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\"," diff --git a/exporters/logging/src/test/java/io/opentelemetry/exporter/logging/LoggingSpanExporterTest.java b/exporters/logging/src/test/java/io/opentelemetry/exporter/logging/LoggingSpanExporterTest.java index 6e48a59d7e..29cff94244 100644 --- 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) diff --git 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 index 9078a587e7..bc4c96ecfc 100644 --- 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> setter = Map::put; private static final TextMapPropagator.Getter> 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 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 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 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 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 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 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()); diff --git 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 index 77725298f0..675382ea23 100644 --- 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(), diff --git 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 index 2d321d5cc6..1fdd76a074 100644 --- 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()); diff --git 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 index c24d77d6e1..a049ea5ce4 100644 --- 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") diff --git a/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanBuilderTest.java b/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanBuilderTest.java index e7c21a2b0c..9a8b1aa652 100644 --- 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())