brave.propagation.CurrentTraceContext Java Examples

protected ITRemote() {
  CurrentTraceContext.Builder currentTraceContextBuilder = currentTraceContextBuilder();
  if (currentTraceContextBuilder instanceof StrictCurrentTraceContext.Builder) {
    currentTraceContext = currentTraceContextBuilder.build();
    checkForLeakedScopes = (Closeable) currentTraceContext;
  } else {
    StrictScopeDecorator strictScopeDecorator = StrictScopeDecorator.create();
    currentTraceContext = currentTraceContextBuilder
      .addScopeDecorator(strictScopeDecorator).build();
    checkForLeakedScopes = strictScopeDecorator;
  }
  propagationFactory = BaggagePropagation.newFactoryBuilder(B3Propagation.FACTORY)
    .add(SingleBaggageField.newBuilder(BAGGAGE_FIELD)
      .addKeyName(BAGGAGE_FIELD_KEY)
      .build()).build();
  tracing = tracingBuilder(Sampler.ALWAYS_SAMPLE).build();
}
 

@Bean
CurrentTraceContext sleuthCurrentTraceContext(CurrentTraceContext.Builder builder,
		@Nullable List<CurrentTraceContext.ScopeDecorator> scopeDecorators,
		@Nullable List<CurrentTraceContextCustomizer> currentTraceContextCustomizers) {
	if (scopeDecorators == null) {
		scopeDecorators = Collections.emptyList();
	}
	if (currentTraceContextCustomizers == null) {
		currentTraceContextCustomizers = Collections.emptyList();
	}

	for (CurrentTraceContext.ScopeDecorator scopeDecorator : scopeDecorators) {
		builder.addScopeDecorator(scopeDecorator);
	}
	for (CurrentTraceContextCustomizer customizer : currentTraceContextCustomizers) {
		customizer.customize(builder);
	}
	return builder.build();
}
 

@Bean
@ConditionalOnMissingBean
// NOTE: stable bean name as might be used outside sleuth
Tracing tracing(@LocalServiceName String serviceName, Propagation.Factory factory,
		CurrentTraceContext currentTraceContext, Sampler sampler,
		SleuthProperties sleuthProperties, @Nullable List<SpanHandler> spanHandlers,
		@Nullable List<TracingCustomizer> tracingCustomizers) {
	Tracing.Builder builder = Tracing.newBuilder().sampler(sampler)
			.localServiceName(StringUtils.isEmpty(serviceName) ? DEFAULT_SERVICE_NAME
					: serviceName)
			.propagationFactory(factory).currentTraceContext(currentTraceContext)
			.traceId128Bit(sleuthProperties.isTraceId128())
			.supportsJoin(sleuthProperties.isSupportsJoin());
	if (spanHandlers != null) {
		for (SpanHandler spanHandlerFactory : spanHandlers) {
			builder.addSpanHandler(spanHandlerFactory);
		}
	}
	if (tracingCustomizers != null) {
		for (TracingCustomizer customizer : tracingCustomizers) {
			customizer.customize(builder);
		}
	}

	return builder.build();
}
 

@Test
public void should_scope_scalar_hide_subscribe() {
	springContext.registerBean(CurrentTraceContext.class, () -> currentTraceContext);
	springContext.refresh();

	Function<? super Publisher<Integer>, ? extends Publisher<Integer>> transformer = scopePassingSpanOperator(
			this.springContext);

	try (Scope ws = this.currentTraceContext.newScope(context)) {

		transformer.apply(Mono.just(1).hide())
				.subscribe(assertScopePassingSpanSubscriber);

		transformer.apply(Mono.<Integer>error(new Exception()).hide())
				.subscribe(assertScopePassingSpanSubscriber);

		transformer.apply(Mono.<Integer>empty().hide())
				.subscribe(assertScopePassingSpanSubscriber);
	}
}
 

@Test
public void should_not_scope_scalar_subscribe() {
	springContext.registerBean(CurrentTraceContext.class, () -> currentTraceContext);
	springContext.refresh();

	Function<? super Publisher<Integer>, ? extends Publisher<Integer>> transformer = scopePassingSpanOperator(
			this.springContext);

	try (Scope ws = this.currentTraceContext.newScope(context)) {

		transformer.apply(Mono.just(1))
				.subscribe(assertNotScopePassingSpanSubscriber);

		transformer.apply(Mono.error(new Exception()))
				.subscribe(assertNotScopePassingSpanSubscriber);

		transformer.apply(Mono.empty())
				.subscribe(assertNotScopePassingSpanSubscriber);

	}
}
 

Tracer(
  Clock clock,
  Propagation.Factory propagationFactory,
  SpanHandler spanHandler,
  PendingSpans pendingSpans,
  Sampler sampler,
  CurrentTraceContext currentTraceContext,
  boolean traceId128Bit,
  boolean supportsJoin,
  boolean alwaysSampleLocal,
  AtomicBoolean noop
) {
  this.clock = clock;
  this.propagationFactory = propagationFactory;
  this.spanHandler = spanHandler;
  this.pendingSpans = pendingSpans;
  this.sampler = sampler;
  this.currentTraceContext = currentTraceContext;
  this.traceId128Bit = traceId128Bit;
  this.supportsJoin = supportsJoin;
  this.alwaysSampleLocal = alwaysSampleLocal;
  this.noop = noop;
}
 

void eachTaskHasCorrectSpanAttached(Callable<?> scheduleTwoTasks) throws Exception {
  // First task should block the queue, forcing the latter to not be scheduled immediately
  // Both should have the same parent, as the parent applies to the task creation time, not
  // execution time.
  try (CurrentTraceContext.Scope ws = currentTraceContext.newScope(context)) {
    scheduleTwoTasks.call();
  }

  // switch the current span to something else. If there's a bug, when the
  // second runnable starts, it will have this span as opposed to the one it was
  // invoked with
  try (CurrentTraceContext.Scope ws = currentTraceContext.newScope(context2)) {
    latch.countDown();
    shutdownExecutor();
    assertThat(threadValues)
      .containsExactly(context, context);
  }
}
 

protected void is_inheritable(CurrentTraceContext inheritableCurrentTraceContext)
  throws Exception {
  // use a single-threaded version of newCachedThreadPool
  ExecutorService service = new ThreadPoolExecutor(0, 1,
    60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());

  // submitting a job grows the pool, attaching the context to its thread
  try (Scope scope = inheritableCurrentTraceContext.newScope(context)) {
    assertThat(service.submit(inheritableCurrentTraceContext::get).get())
      .isEqualTo(context);
  }

  // same thread executes the next job and still has the same context (leaked and not cleaned up)
  assertThat(service.submit(inheritableCurrentTraceContext::get).get())
    .isEqualTo(context);

  service.shutdownNow();
}
 

@Bean
SpanHandler uncaughtExceptionThrown(CurrentTraceContext currentTraceContext) {
	return new SpanHandler() {
		@Override
		public boolean end(TraceContext context, MutableSpan span, Cause cause) {
			if (span.kind() != Kind.SERVER || span.error() == null
					|| !log.isErrorEnabled()) {
				return true; // don't add overhead as we only log server errors
			}

			// In TracingFilter, the exception is raised in scope. This is is more
			// explicit to ensure it works in other tech such as WebFlux.
			try (Scope scope = currentTraceContext.maybeScope(context)) {
				log.error("Uncaught exception thrown", span.error());
			}
			return true;
		}

		@Override
		public String toString() {
			return "UncaughtExceptionThrown";
		}
	};
}
 

/**
 * Like {@link CurrentTraceContext#get()}, except it first checks the reactor context.
 */
static TraceContext traceContext(Context context, CurrentTraceContext fallback) {
	if (context.hasKey(TraceContext.class)) {
		return context.get(TraceContext.class);
	}
	return fallback.get();
}
 

@Override
protected AnnotationConfigApplicationContext newClient(int port) {
	AnnotationConfigApplicationContext result = new AnnotationConfigApplicationContext();
	URI baseUrl = URI.create("http://127.0.0.1:" + server.getPort());
	result.registerBean(HttpTracing.class, () -> httpTracing);
	result.registerBean(CurrentTraceContext.class,
			() -> httpTracing.tracing().currentTraceContext());
	result.registerBean(HttpClient.class, () -> testHttpClient(baseUrl));
	result.registerBean(URI.class, () -> baseUrl);
	result.register(componentClasses);
	result.refresh();
	return result;
}
 

@Override
public void onMessage(Message message, Session session) throws JMSException {
	Span span = this.jmsTracing.nextSpan(message).name("on-message").start();
	try (CurrentTraceContext.Scope ws = this.current.newScope(span.context())) {
		super.onMessage(message, session);
	}
	catch (JMSException | RuntimeException | Error e) {
		span.error(e);
		throw e;
	}
	finally {
		span.finish();
	}
}
 

private CurrentTraceContext currentTraceContext() {
	if (this.currentTraceContext == null) {
		this.currentTraceContext = this.beanFactory
				.getBean(CurrentTraceContext.class);
	}
	return this.currentTraceContext;
}
 

CurrentTraceContext currentTraceContext() {
	if (this.currentTraceContext == null) {
		this.currentTraceContext = this.beanFactory
				.getBean(CurrentTraceContext.class);
	}
	return this.currentTraceContext;
}
 

@Override public void run() {
  CurrentTraceContext currentTraceContext =
    ThreadLocalCurrentTraceContext.newBuilder().build();
  SavedHooks saved = new CurrentTraceContextAssemblyTracking(currentTraceContext)
    .enableAndChain();

  TraceContext assembly = TraceContext.newBuilder().traceId(1).spanId(1).build();

  try (Scope scope = currentTraceContext.newScope(assembly)) {
    Observable.just(1).map(i -> i).test().assertNoErrors();
  } finally {
    saved.restore();
  }
}
 

ScopePassingSpanSubscriber(Subscriber<? super T> subscriber, Context ctx,
		CurrentTraceContext currentTraceContext, @Nullable TraceContext parent) {
	this.subscriber = subscriber;
	this.currentTraceContext = currentTraceContext;
	this.parent = parent;
	this.context = parent != null
			&& !parent.equals(ctx.getOrDefault(TraceContext.class, null))
					? ctx.put(TraceContext.class, parent) : ctx;
	if (log.isTraceEnabled()) {
		log.trace("Parent span [" + parent + "], context [" + this.context + "]");
	}
}
 

/**
 * Get or build tracing.
 */
public static Tracing getTracing(String serviceName, CurrentTraceContext context) {
    Tracing tracing = Tracing.current();
    if (tracing == null) {
        // TODO reporter based on prop/config
        tracing = getBuilder(serviceName, context).build();
    }
    return tracing;
}
 

@Test
public void execute() throws Exception {
  final TraceContext[] threadValues = new TraceContext[2];

  CountDownLatch latch = new CountDownLatch(1);
  // First task should block the queue, forcing the latter to not be scheduled immediately
  // Both should have the same parent, as the parent applies to the task creation time, not
  // execution time.
  try (CurrentTraceContext.Scope ws = currentTraceContext.newScope(context)) {
    executor.execute(() -> {
      threadValues[0] = currentTraceContext.get();
      try {
        latch.await();
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        e.printStackTrace();
      }
    });
    // this won't run immediately because the other is blocked
    executor.execute(() -> threadValues[1] = currentTraceContext.get());
  }

  // switch the current span to something else. If there's a bug, when the
  // second runnable starts, it will have this span as opposed to the one it was
  // invoked with
  try (CurrentTraceContext.Scope ws = currentTraceContext.newScope(context2)) {
    latch.countDown();
    shutdownExecutor();
    assertThat(threadValues)
      .containsExactly(context, context);
  }
}
 

private static Tracing newTracing(String name) {
    final CurrentTraceContext currentTraceContext =
            RequestContextCurrentTraceContext.builder()
                                             .nonRequestThread("nonrequest-")
                                             .addScopeDecorator(StrictScopeDecorator.create())
                                             .build();
    return Tracing.newBuilder()
                  .currentTraceContext(currentTraceContext)
                  .localServiceName(name)
                  .addSpanHandler(spanHandler)
                  .sampler(Sampler.ALWAYS_SAMPLE)
                  .build();
}
 

@Test public void ignoresNoopScopeDecorator() {
  ScopeDecorator one = (context, scope) -> scope;

  CurrentTraceContext shouldHaveOnlyOne = newBuilder()
    .addScopeDecorator(ScopeDecorator.NOOP)
    .addScopeDecorator(one).build();

  assertThat(shouldHaveOnlyOne).extracting("scopeDecorators")
    .asInstanceOf(InstanceOfAssertFactories.ARRAY)
    .doesNotContain(ScopeDecorator.NOOP);
}
 

@Test public void newScope_decoratesWithDifferentScope() {
  Scope differentScope = () -> {
  };

  CurrentTraceContext decoratesWithDifferentScope = newBuilder()
    .addScopeDecorator((context, scope) -> differentScope).build();

  try (Scope scope = decoratesWithDifferentScope.newScope(context)) {
    assertThat(scope).isSameAs(differentScope);
  }

  try (Scope scope = decoratesWithDifferentScope.newScope(null)) {
    assertThat(scope).isSameAs(differentScope);
  }
}
 

/**
 * Returns a scope decorator that configures {@link BaggageFields#TRACE_ID}, {@link
 * BaggageFields#PARENT_ID}, {@link BaggageFields#SPAN_ID} and {@link BaggageFields#SAMPLED}
 *
 * @since 5.2
 * @deprecated since 5.11 use {@link #get()} or {@link #newBuilder()}
 */
@Deprecated public static CurrentTraceContext.ScopeDecorator create() {
  return new Builder()
    .clear()
    .add(SingleCorrelationField.create(BaggageFields.TRACE_ID))
    .add(SingleCorrelationField.create(BaggageFields.PARENT_ID))
    .add(SingleCorrelationField.create(BaggageFields.SPAN_ID))
    .add(SingleCorrelationField.create(BaggageFields.SAMPLED))
    .build();
}
 

HttpServerParserAdapter(
  HttpRequestParser requestParser,
  HttpResponseParser responseParser,
  CurrentTraceContext currentTraceContext,
  ErrorParser errorParser
) {
  this.requestParser = requestParser;
  this.responseParser = responseParser;
  this.currentTraceContext = currentTraceContext;
  this.errorParser = errorParser;
}
 

@Test public void handleSendWithParent_overrideNull() {
  try (CurrentTraceContext.Scope ws = httpTracing.tracing.currentTraceContext().newScope(null)) {
    brave.Span span = handler.handleSendWithParent(request, context);

    // If the overwrite was successful, we have a child span.
    assertThat(span.context().parentIdAsLong()).isEqualTo(context.spanId());
  }
}
 

/**
 * Returns a scope decorator that configures {@link BaggageFields#TRACE_ID}, {@link
 * BaggageFields#PARENT_ID}, {@link BaggageFields#SPAN_ID} and {@link BaggageFields#SAMPLED}
 *
 * @since 5.2
 * @deprecated since 5.11 use {@link #get()} or {@link #newBuilder()}
 */
@Deprecated public static CurrentTraceContext.ScopeDecorator create() {
  return new Builder()
    .clear()
    .add(SingleCorrelationField.create(BaggageFields.TRACE_ID))
    .add(SingleCorrelationField.create(BaggageFields.PARENT_ID))
    .add(SingleCorrelationField.create(BaggageFields.SPAN_ID))
    .add(SingleCorrelationField.create(BaggageFields.SAMPLED))
    .build();
}
 

public static Completable wrap(
  CompletableSource source, CurrentTraceContext contextScoper, TraceContext assembled) {
  if (source instanceof Callable) {
    return new TraceContextCallableCompletable<>(source, contextScoper, assembled);
  }
  return new TraceContextCompletable(source, contextScoper, assembled);
}
 

public static <T> Maybe<T> wrap(
  MaybeSource<T> source, CurrentTraceContext contextScoper, TraceContext assembled) {
  if (source instanceof Callable) {
    return new TraceContextCallableMaybe<>(source, contextScoper, assembled);
  }
  return new TraceContextMaybe<>(source, contextScoper, assembled);
}
 

public static <T> Single<T> wrap(
  SingleSource<T> source, CurrentTraceContext contextScoper, TraceContext assembled) {
  if (source instanceof Callable) {
    return new TraceContextCallableSingle<>(source, contextScoper, assembled);
  }
  return new TraceContextSingle<>(source, contextScoper, assembled);
}
 

public static <T> Observable<T> wrap(
  ObservableSource<T> source, CurrentTraceContext contextScoper, TraceContext assembled) {
  if (source instanceof Callable) {
    return new TraceContextCallableObservable<>(source, contextScoper, assembled);
  }
  return new TraceContextObservable<>(source, contextScoper, assembled);
}
 

public static <T> Flowable<T> wrap(
  Publisher<T> source, CurrentTraceContext contextScoper, TraceContext assembled) {
  if (source instanceof Callable) {
    return new TraceContextCallableFlowable<>(source, contextScoper, assembled);
  }
  return new TraceContextFlowable<>(source, contextScoper, assembled);
}