io.opentracing.tag.Tag Java Examples

private void tagIfMatch(
        final Span span,
        final Class<? extends InetAddress> type, final Tag<String> tag,
        final InetAddress address) {

    if (type.isInstance(address)) {
        span.setTag(tag, address.getHostAddress());
    }
}
 

@Override
public <T> SpanBuilder withTag(Tag<T> tag, T value) {
  if (value instanceof String) {
    this.withTag(tag.getKey(), (String) value);
  } else if (value instanceof Boolean) {
    this.withTag(tag.getKey(), (Boolean) value);
  } else if (value instanceof Number) {
    this.withTag(tag.getKey(), (Number) value);
  } else {
    this.withTag(tag.getKey(), value.toString());
  }

  return this;
}
 

/**
 * Creates a mocked OpenTracing SpanBuilder for creating a given Span.
 * <p>
 * All invocations on the mock are stubbed to return the builder by default.
 *
 * @param spanToCreate The object that the <em>start</em> method of the
 *                     returned builder should produce.
 * @return The builder.
 */
@SuppressWarnings("unchecked")
public static SpanBuilder mockSpanBuilder(final Span spanToCreate) {
    final SpanBuilder spanBuilder = mock(SpanBuilder.class, Mockito.RETURNS_SMART_NULLS);
    when(spanBuilder.addReference(anyString(), any())).thenReturn(spanBuilder);
    when(spanBuilder.withTag(anyString(), anyBoolean())).thenReturn(spanBuilder);
    when(spanBuilder.withTag(anyString(), (String) any())).thenReturn(spanBuilder);
    when(spanBuilder.withTag(anyString(), (Number) any())).thenReturn(spanBuilder);
    when(spanBuilder.withTag(any(Tag.class), any())).thenReturn(spanBuilder);
    when(spanBuilder.ignoreActiveSpan()).thenReturn(spanBuilder);
    when(spanBuilder.start()).thenReturn(spanToCreate);
    return spanBuilder;
}
 

/**
 * Sets up the fixture.
 */
@SuppressWarnings("unchecked")
@BeforeEach
void setUp(final Vertx vertx, final VertxTestContext testContext) {

    final var cacheManager = new DefaultCacheManager(false);
    cacheManager.defineConfiguration("cache-name", new ConfigurationBuilder()
            .build());
    cache = new EmbeddedCache<>(vertx, cacheManager, "cache-name", "foo", "bar");
    cache.connect().onComplete(testContext.completing());

    final SpanContext spanContext = mock(SpanContext.class);
    span = mock(Span.class);
    when(span.context()).thenReturn(spanContext);
    final Tracer.SpanBuilder spanBuilder = mock(Tracer.SpanBuilder.class, Mockito.RETURNS_SMART_NULLS);
    when(spanBuilder.addReference(anyString(), any())).thenReturn(spanBuilder);
    when(spanBuilder.withTag(anyString(), anyBoolean())).thenReturn(spanBuilder);
    when(spanBuilder.withTag(anyString(), (String) any())).thenReturn(spanBuilder);
    when(spanBuilder.withTag(anyString(), (Number) any())).thenReturn(spanBuilder);
    when(spanBuilder.withTag(any(Tag.class), any())).thenReturn(spanBuilder);
    when(spanBuilder.ignoreActiveSpan()).thenReturn(spanBuilder);
    when(spanBuilder.start()).thenReturn(span);
    tracer = mock(Tracer.class);
    when(tracer.buildSpan(anyString())).thenReturn(spanBuilder);

    info = new CacheBasedDeviceConnectionInfo(cache, tracer);
}
 

@Override
public <T> SpanBuilder withTag(final Tag<T> tag, final T value) {
    final TagInterceptor interceptor = plugins.interceptors().tags();
    final TagListener listener = plugins.listeners().tags();

    interceptor.intercept(tag, value).forEach(pair -> {
        pair.tag(delegate);
        pair.notify(listener, this);
    });

    return this;
}
 

@Override
public <T> Span setTag(final Tag<T> tag, final T value) {
    final TagInterceptor interceptor = plugins.interceptors().tags();
    final TagListener listener = plugins.listeners().tags();

    interceptor.intercept(tag, value).forEach(pair -> {
        pair.tag(delegate);
        pair.notify(listener, this);
    });

    return this;
}
 

@Override
public <T> Collection<TagPair> intercept(
        final Tag<T> tag, final T value) {

    return interceptors.stream()
            .map(interceptor -> interceptor.intercept(tag, value))
            .flatMap(Collection::stream)
            .collect(toList());
}
 

@Override
public <T> void onTag(final Span span, final Tag<T> tag, final T value) {
    if (baggageExists(span)) {
        return;
    }

    if (tagKey.equals(tag.getKey())) {
        span.setBaggageItem(baggageKey, String.valueOf(value));
    }
}
 

static HttpSpanTagger tagging(
        final Tag<String> tag,
        final String name,
        final String... names) {

    return tagging(ImmutableMap.of(tag, Lists.asList(name, names)));
}
 

default <T> void onTag(
        final Span span,
        final Tag<T> tag,
        final T value) {

    // nothing to do
}
 

default <T> void onTag(
        final SpanBuilder builder,
        final Tag<T> tag,
        final T value) {

    // nothing to do
}
 

@Override public <T> BraveSpanBuilder withTag(Tag<T> tag, T value) {
  if (tag == null) throw new NullPointerException("tag == null");
  if (value == null) throw new NullPointerException("value == null");
  if (value instanceof String) return withTag(tag.getKey(), (String) value);
  if (value instanceof Number) return withTag(tag.getKey(), (Number) value);
  if (value instanceof Boolean) return withTag(tag.getKey(), (Boolean) value);
  throw new IllegalArgumentException("tag value not a string, number or boolean: " + value);
}
 

@Override
public <T> void onTag(
        final SpanBuilder builder,
        final Tag<T> tag,
        final T value) {

    listeners.forEach(listener ->
            listener.onTag(builder, tag, value));
}
 

@SuppressWarnings("unchecked")
private static <T> void propagate(
        final Map<Tag<?>, Object> tags,
        final BiConsumer<Tag<T>, T> consumer) {

    tags.forEach((raw, value) -> {
        final Tag<T> tag = (Tag<T>) raw;
        consumer.accept(tag, (T) value);
    });
}
 

@Override
public <T> SpanBuilder withTag(final Tag<T> tag, final T value) {
    with(tag, value);
    return ForwardingSpanBuilder.super.withTag(tag, value);
}
 

@Override
public <T> NoopSpan setTag(Tag<T> tag, T value) { return this; }
 

@Override
default <T> SpanBuilder withTag(final Tag<T> tag, final T value) {
    delegate().withTag(tag, value);
    return this;
}
 

@Override
default  <T> Span setTag(final Tag<T> tag, final T value) {
    delegate().setTag(tag, value);
    return this;
}
 

/** Same as {@link AbstractTag#set(Span, T)}, but for the span being built. */
<T> SpanBuilder withTag(Tag<T> tag, T value);
 

private <T> void with(final Tag<T> tag, final T value) {
    if (keys.contains(tag.getKey())) {
        tags.put(tag, value);
    }
}
 

@Override
public <T> Span setTag(final Tag<T> tag, final T value) {
    set(tag, value);
    return delegate.setTag(tag, value);
}
 

private <T> void set(final Tag<T> tag, final T value) {
    if (keys.contains(tag.getKey())) {
        tags.put(tag, value);
    }
}
 

@Override
public <T> void onTag(final Span span, final Tag<T> tag, final T value) {
    listeners.forEach(listener ->
            listener.onTag(span, tag, value));
}
 

static <T> TagPair of(final Tag<T> tag, final T value) {
    return new DefaultTagPair<>(tag, value);
}
 

@CheckReturnValue
default <T> Collection<TagPair> intercept(
        final Tag<T> tag, final T value) {

    return singleton(TagPair.of(tag, value));
}
 

private static <T> Tag<T> tag(final String key) {
    return argThat(tag -> key.equals(tag.getKey()));
}
 

@Override
public <T> Collection<TagPair> intercept(final Tag<T> tag, final T value) {
    return singleton(TagPair.of(new StringTag("type"), "test"));
}
 

@Override
public <T> Collection<TagPair> intercept(final Tag<T> tag, final T value) {
    return singletonList(TagPair.of(new IntTag("v"), 1));
}
 

@Override public <T> Span setTag(Tag<T> tag, T t) {
  if (t instanceof String) return setTag(tag.getKey(), (String) t);
  if (t instanceof Number) return setTag(tag.getKey(), (Number) t);
  if (t instanceof Boolean) return setTag(tag.getKey(), (Boolean) t);
  throw new IllegalArgumentException("tag value not a string, number or boolean: " + tag);
}
 

@Override public <T> BraveSpanBuilder withTag(Tag<T> tag, T t) {
  if (t instanceof String) return withTag(tag.getKey(), (String) t);
  if (t instanceof Number) return withTag(tag.getKey(), (Number) t);
  if (t instanceof Boolean) return withTag(tag.getKey(), (Boolean) t);
  throw new IllegalArgumentException("tag value not a string, number or boolean: " + tag);
}