How to use

withDurationNanos

method

in

com.nike.wingtips.Span$Builder

.withParentSpanId(badParentSpanId)
.withSpanStartTimeEpochMicros(Math.abs(random.nextLong()))
.withDurationNanos(Math.abs(random.nextLong()))
.build();

@UseDataProvider("idSanitizationScenarios")
@Test
public void convertWingtipsSpanToZipkinSpan_sanitizes_parentSpanId_as_expected_when_sanitization_is_enabled(
  IdSanitizationScenario scenario
) {
  // given
  impl = new WingtipsToZipkinSpanConverterDefaultImpl(true);
  final Endpoint zipkinEndpoint = Endpoint.newBuilder().serviceName(UUID.randomUUID().toString()).build();
  final Span wingtipsSpan = Span.newBuilder("foo", SpanPurpose.CLIENT)
                 .withParentSpanId(scenario.originalId)
                 .withSpanStartTimeEpochMicros(Math.abs(random.nextLong()))
                 .withDurationNanos(Math.abs(random.nextLong()))
                 .build();
  // when
  zipkin2.Span zipkinSpan = impl.convertWingtipsSpanToZipkinSpan(wingtipsSpan, zipkinEndpoint);
  // then
  assertThat(zipkinSpan.parentId()).isEqualTo(scenario.expectedSanitizedResultForSpanIdOrParentSpanId);
  assertThat(zipkinSpan.tags().get("invalid.parent_id")).isEqualTo(scenario.originalId);
}

@UseDataProvider("idSanitizationScenarios")
@Test
public void convertWingtipsSpanToZipkinSpan_sanitizes_traceId_as_expected_when_sanitization_is_enabled(
  IdSanitizationScenario scenario
) {
  // given
  impl = new WingtipsToZipkinSpanConverterDefaultImpl(true);
  final Endpoint zipkinEndpoint = Endpoint.newBuilder().serviceName(UUID.randomUUID().toString()).build();
  final Span wingtipsSpan = Span.newBuilder("foo", SpanPurpose.CLIENT)
      .withTraceId(scenario.originalId)
      .withSpanStartTimeEpochMicros(Math.abs(random.nextLong()))
      .withDurationNanos(Math.abs(random.nextLong()))
      .build();
  String expectedZipkinInvalidIdTagValue = (scenario.expectedSanitizedResultForTraceId.equals(scenario.originalId))
                       ? null
                       : scenario.originalId;
  // when
  zipkin2.Span zipkinSpan = impl.convertWingtipsSpanToZipkinSpan(wingtipsSpan, zipkinEndpoint);
  // then
  assertThat(zipkinSpan.traceId()).isEqualTo(scenario.expectedSanitizedResultForTraceId);
  assertThat(zipkinSpan.tags().get("invalid.trace_id")).isEqualTo(expectedZipkinInvalidIdTagValue);
}

.withSpanStartTimeEpochMicros(startTimeEpochMicrosForFullyCompleteSpan)
.withSpanStartTimeNanos(startTimeNanosForFullyCompleteSpan)
.withDurationNanos(durationNanosForFullyCompletedSpan)
.withTags(tags)
.withTag(extraTagKey, extraTagValue)

@DataProvider(value = {
    "   \t\n\r   ",
    ""
}, splitBy = "\\|")
@Test
@SuppressWarnings("UnnecessaryLocalVariable")
public void convertWingtipsSpanToZipkinSpan_throws_IllegalArgumentException_when_passed_wingtipsSpan_with_empty_traceId_format(
  final String emptyString
) {
  // given
  String emptyTraceId = emptyString;
  long startTimeEpochMicros = Math.abs(random.nextLong());
  long durationNanos = Math.abs(random.nextLong());
  final Endpoint zipkinEndpoint = Endpoint.newBuilder().serviceName(UUID.randomUUID().toString()).build();
  final Span wingtipsSpan = Span.newBuilder("foo", SpanPurpose.CLIENT)
      .withTraceId(emptyTraceId)
      .withSpanStartTimeEpochMicros(startTimeEpochMicros)
      .withDurationNanos(durationNanos)
      .build();
  // when
  Throwable ex = catchThrowable(() -> impl.convertWingtipsSpanToZipkinSpan(wingtipsSpan, zipkinEndpoint));
  // then
  assertThat(ex)
    .isInstanceOf(IllegalArgumentException.class)
    .hasMessage("traceId is empty");
}

@UseDataProvider("idSanitizationScenarios")
@Test
public void convertWingtipsSpanToZipkinSpan_does_not_sanitize_ids_if_enableIdSanitization_is_false(
  IdSanitizationScenario scenario
) {
  // given
  impl = new WingtipsToZipkinSpanConverterDefaultImpl(false);
  final Endpoint zipkinEndpoint = Endpoint.newBuilder().serviceName(UUID.randomUUID().toString()).build();
  final Span wingtipsSpan = Span.newBuilder("foo", SpanPurpose.CLIENT)
                 .withTraceId(scenario.originalId)
                 .withSpanId(scenario.originalId)
                 .withSpanStartTimeEpochMicros(Math.abs(random.nextLong()))
                 .withDurationNanos(Math.abs(random.nextLong()))
                 .build();
  String expectedExceptionMessageSuffix = (scenario.originalId.length() > 16)
                      ? "id.length > 16"
                      : "should be lower-hex encoded with no prefix";
  // when
  Throwable ex = catchThrowable(() -> impl.convertWingtipsSpanToZipkinSpan(wingtipsSpan, zipkinEndpoint));
  // then
  assertThat(ex)
    .isInstanceOf(IllegalArgumentException.class)
    .hasMessageEndingWith(expectedExceptionMessageSuffix);
}

@Test
@SuppressWarnings("UnnecessaryLocalVariable")
public void convertWingtipsSpanToZipkinSpan_works_as_expected_for_128_bit_trace_id() {
  // given
  String high64Bits = "463ac35c9f6413ad";
  String low64Bits = "48485a3953bb6124";
  String traceId128Bits = high64Bits + low64Bits;
  long startTimeEpochMicros = Math.abs(random.nextLong());
  long durationNanos = Math.abs(random.nextLong());
  Endpoint zipkinEndpoint = Endpoint.newBuilder().serviceName(UUID.randomUUID().toString()).build();
  Span wingtipsSpan = Span.newBuilder("foo", SpanPurpose.CLIENT)
              .withTraceId(traceId128Bits)
              .withSpanStartTimeEpochMicros(startTimeEpochMicros)
              .withDurationNanos(durationNanos)
              .build();
  // when
  zipkin2.Span zipkinSpan = impl.convertWingtipsSpanToZipkinSpan(wingtipsSpan, zipkinEndpoint);
  // then
  assertThat(zipkinSpan.traceId()).isEqualTo(traceId128Bits);
}

@UseDataProvider("idSanitizationScenarios")
@Test
public void convertWingtipsSpanToZipkinSpan_sanitizes_spanId_as_expected_when_sanitization_is_enabled(
  IdSanitizationScenario scenario
) {
  // given
  impl = new WingtipsToZipkinSpanConverterDefaultImpl(true);
  final Endpoint zipkinEndpoint = Endpoint.newBuilder().serviceName(UUID.randomUUID().toString()).build();
  final Span wingtipsSpan = Span.newBuilder("foo", SpanPurpose.CLIENT)
                 .withSpanId(scenario.originalId)
                 .withSpanStartTimeEpochMicros(Math.abs(random.nextLong()))
                 .withDurationNanos(Math.abs(random.nextLong()))
                 .build();
  // when
  zipkin2.Span zipkinSpan = impl.convertWingtipsSpanToZipkinSpan(wingtipsSpan, zipkinEndpoint);
  // then
  assertThat(zipkinSpan.id()).isEqualTo(scenario.expectedSanitizedResultForSpanIdOrParentSpanId);
  assertThat(zipkinSpan.tags().get("invalid.span_id")).isEqualTo(scenario.originalId);
}

/**
 * @param spanName The {@link Span#getSpanName()} to use for the new child sub-span.
 * @param spanPurpose The {@link SpanPurpose} for the new child span. See the javadocs for {@link SpanPurpose} for full details on what each enum option
 *                    means. If you pass in null for this then {@link SpanPurpose#UNKNOWN} will be used.
 * @return A new uncompleted span representing a child of this instance. The returned instance's {@link #getParentSpanId()} will be this instance's
 *          {@link #getSpanId()}, its {@link #getSpanName()} will be the given value, its {@link #getSpanId()} will be randomly generated, and its
 *          {@link #getSpanStartTimeEpochMicros()} and {@link #getSpanStartTimeNanos()} values will be set to the appropriate values based on when this
 *          method is called. It will share this instance's {@link #getTraceId()}, {@link #isSampleable()}, and {@link #getUserId()} values.
 */
public Span generateChildSpan(String spanName, SpanPurpose spanPurpose) {
  return Span.newBuilder(spanName, spanPurpose)
        .withTraceId(this.getTraceId())
        .withSampleable(this.isSampleable())
        .withUserId(this.getUserId())
        .withParentSpanId(this.getSpanId())
        .withSpanId(TraceAndSpanIdGenerator.generateId())
        .withSpanStartTimeEpochMicros(TimeUnit.MILLISECONDS.toMicros(System.currentTimeMillis()))
        .withSpanStartTimeNanos(System.nanoTime())
        .withDurationNanos(null)
        .build();
}