brave.propagation.B3SingleFormat Java Examples

/** This mainly shows endpoints are taken from Brave, and error is back-filled. */
@Test public void basicSpan() {
  TraceContext context = B3SingleFormat.parseB3SingleFormat(
      "50d980fffa300f29-86154a4ba6e91385-1"
  ).context();

  tracing.tracer().toSpan(context).name("test")
      .start(1L)
      .error(new RuntimeException("this cake is a lie"))
      .finish(3L);

  triggerReport();

  assertThat(spans.get(0)).hasToString(
      "{\"traceId\":\"50d980fffa300f29\","
          + "\"id\":\"86154a4ba6e91385\","
          + "\"name\":\"test\","
          + "\"timestamp\":1,"
          + "\"duration\":2,"
          + "\"localEndpoint\":{"
          + "\"serviceName\":\"aa\","
          + "\"ipv4\":\"1.2.3.4\","
          + "\"port\":80},"
          + "\"tags\":{\"error\":\"this cake is a lie\"}}"
  );
}
 

/** This mainly shows endpoints are taken from Brave, and error is back-filled. */
@Test public void basicSpan() {
  TraceContext context = B3SingleFormat.parseB3SingleFormat(
      "50d980fffa300f29-86154a4ba6e91385-1"
  ).context();

  tracing.tracer().toSpan(context).name("test")
      .start(1L)
      .error(new RuntimeException("this cake is a lie"))
      .finish(3L);

  reporter.flush();

  assertThat(zipkin.getTraces()).hasSize(1).first().hasToString(
      "[{\"traceId\":\"50d980fffa300f29\","
          + "\"id\":\"86154a4ba6e91385\","
          + "\"name\":\"test\","
          + "\"timestamp\":1,"
          + "\"duration\":2,"
          + "\"localEndpoint\":{"
          + "\"serviceName\":\"aa\","
          + "\"ipv4\":\"1.2.3.4\","
          + "\"port\":80},"
          + "\"tags\":{\"error\":\"this cake is a lie\"}}]"
  );
}
 

@Test public void createsChildWhenJoinDisabled() throws IOException {
  tracing = tracingBuilder(NEVER_SAMPLE).supportsJoin(false).build();
  httpTracing = HttpTracing.create(tracing);
  init();

  String path = "/foo";

  TraceContext parent = newTraceContext(SamplingFlags.SAMPLED);
  get(new Request.Builder().url(url(path))
    .header("b3", B3SingleFormat.writeB3SingleFormat(parent))
    .build());

  MutableSpan span = testSpanHandler.takeRemoteSpan(SERVER);
  assertChildOf(span, parent);
  assertThat(span.id()).isNotEqualTo(parent.spanIdString());
}
 

@Test public void reusesPropagatedSpanId() {
  TraceContext parent = newTraceContext(SamplingFlags.SAMPLED);

  RpcContext.getContext().getAttachments().put("b3", B3SingleFormat.writeB3SingleFormat(parent));
  client.get().sayHello("jorge");

  assertSameIds(testSpanHandler.takeRemoteSpan(SERVER), parent);
}
 

@Test public void should_prefer_current_span() {
  // Will be either a bug, or a missing processor stage which can result in an old span in headers
  Message message = MessageBuilder.withBody(new byte[0]).build();
  message.getMessageProperties().setHeader("b3", B3SingleFormat.writeB3SingleFormat(grandparent));

  Message postProcessMessage;
  try (Scope scope = tracing.currentTraceContext().newScope(parent)) {
    postProcessMessage = tracingMessagePostProcessor.postProcessMessage(message);
  }

  assertThat(spans.get(0).parentId()).isEqualTo(parent.spanIdString());
  Map<String, Object> headers = postProcessMessage.getMessageProperties().getHeaders();
  assertThat(headers.get("b3").toString()).endsWith("-" + spans.get(0).id() + "-1");
}
 

@Test public void should_retain_baggage() {
  Message message = MessageBuilder.withBody(new byte[0]).build();
  message.getMessageProperties().setHeader("b3", B3SingleFormat.writeB3SingleFormat(parent));
  message.getMessageProperties().setHeader(BAGGAGE_FIELD_KEY, "");

  Message postProcessMessage = tracingMessagePostProcessor.postProcessMessage(message);

  assertThat(spans.get(0).parentId()).isEqualTo(parent.spanIdString());
  Map<String, Object> headers = postProcessMessage.getMessageProperties().getHeaders();
  assertThat(headers.get("b3").toString()).endsWith("-" + spans.get(0).id() + "-1");
  assertThat(headers.get(BAGGAGE_FIELD_KEY).toString()).isEmpty();
}
 

@Test public void should_resume_headers() {
  Message message = MessageBuilder.withBody(new byte[0]).build();
  message.getMessageProperties().setHeader("b3", B3SingleFormat.writeB3SingleFormat(parent));

  Message postProcessMessage = tracingMessagePostProcessor.postProcessMessage(message);

  assertThat(spans.get(0).parentId()).isEqualTo(parent.spanIdString());
  Map<String, Object> headers = postProcessMessage.getMessageProperties().getHeaders();
  assertThat(headers.get("b3").toString()).endsWith("-" + spans.get(0).id() + "-1");
}
 

Channel clientWithB3SingleHeader(TraceContext parent) {
  return ClientInterceptors.intercept(client, new ClientInterceptor() {
    @Override public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
      return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
        @Override public void start(Listener<RespT> responseListener, Metadata headers) {
          headers.put(Key.of("b3", ASCII_STRING_MARSHALLER),
              B3SingleFormat.writeB3SingleFormat(parent));
          super.start(responseListener, headers);
        }
      };
    }
  });
}
 

@Test public void nextSpan_prefers_b3_header() {
  consumerRecord.headers().add("b3", B3SingleFormat.writeB3SingleFormatAsBytes(incoming));

  Span child;
  try (Scope ws = tracing.currentTraceContext().newScope(parent)) {
    child = kafkaTracing.nextSpan(consumerRecord);
  }
  child.finish();

  assertThat(spans.get(0).id()).isEqualTo(child.context().spanIdString());
  assertChildOf(spans.get(0), incoming);
}
 

TraceContext resetB3PropertyWithNewSampledContext(JmsTestRule jms) throws JMSException {
  TraceContext parent = newTraceContext(SamplingFlags.SAMPLED);
  message = jms.newMessage("foo");
  bytesMessage = jms.newBytesMessage("foo");
  String b3 = B3SingleFormat.writeB3SingleFormatWithoutParentId(parent);
  setStringProperty(message, "b3", b3);
  setStringProperty(bytesMessage, "b3", b3);
  lockMessages();
  return parent;
}
 

@Test public void receive_continues_parent_trace_single_header() throws Exception {
  ActiveMQTextMessage message = new ActiveMQTextMessage();
  message.setStringProperty("b3", B3SingleFormat.writeB3SingleFormatWithoutParentId(parent));

  receive(message);

  // Ensure the current span in on the message, not the parent
  MutableSpan consumer = testSpanHandler.takeRemoteSpan(CONSUMER);
  assertChildOf(consumer, parent);

  TraceContext messageContext = parseB3SingleFormat(message.getStringProperty("b3")).context();
  assertThat(messageContext.traceIdString()).isEqualTo(consumer.traceId());
  assertThat(messageContext.spanIdString()).isEqualTo(consumer.id());
}
 

@Test public void listener_continues_parent_trace_single_header() {
  tracingMessageListener =
    new TracingMessageListener(delegate, jmsTracing, false);

  ActiveMQTextMessage message = new ActiveMQTextMessage();
  setStringProperty(message, "b3", B3SingleFormat.writeB3SingleFormatWithoutParentId(parent));

  onMessageConsumed(message);

  // clearing headers ensures later work doesn't try to use the old parent
  assertNoProperties(message);

  assertChildOf(testSpanHandler.takeLocalSpan(), parent);
}
 

@Test public void continues_parent_trace_single_header() {
  ActiveMQTextMessage message = new ActiveMQTextMessage();
  setStringProperty(message, "b3", B3SingleFormat.writeB3SingleFormatWithoutParentId(parent));

  onMessageConsumed(message);

  // clearing headers ensures later work doesn't try to use the old parent
  assertNoProperties(message);

  MutableSpan consumerSpan = testSpanHandler.takeRemoteSpan(CONSUMER);
  MutableSpan listenerSpan = testSpanHandler.takeLocalSpan();

  assertChildOf(consumerSpan, parent);
  assertChildOf(listenerSpan, consumerSpan);
}
 

@Test public void listener_has_no_tags_when_header_present() {
  tracingMessageListener =
    new TracingMessageListener(delegate, jmsTracing, false);

  ActiveMQTextMessage message = new ActiveMQTextMessage();
  setStringProperty(message, "b3", B3SingleFormat.writeB3SingleFormatWithoutParentId(parent));
  message.setDestination(createDestination("foo", QUEUE_TYPE));
  onMessageConsumed(message);

  assertThat(testSpanHandler.takeLocalSpan().tags()).isEmpty();
}
 

@Test public void nextSpan_prefers_b3_header() {
  TraceContext incoming = newTraceContext(SamplingFlags.NOT_SAMPLED);
  setStringProperty(message, "b3", B3SingleFormat.writeB3SingleFormat(incoming));

  Span child;
  try (Scope ws = tracing.currentTraceContext().newScope(parent)) {
    child = jmsTracing.nextSpan(message);
  }
  assertChildOf(child.context(), incoming);
  assertThat(child.isNoop()).isTrue();
}
 

@Test public void reusesPropagatedSpanId() throws IOException {
  String path = "/foo";

  TraceContext parent = newTraceContext(SamplingFlags.SAMPLED);
  get(new Request.Builder().url(url(path))
    .header("b3", B3SingleFormat.writeB3SingleFormat(parent))
    .build());

  assertSameIds(testSpanHandler.takeRemoteSpan(SERVER), parent);
}
 

@Test public void createsChildWhenJoinDisabled() {
  tracing = tracingBuilder(NEVER_SAMPLE).supportsJoin(false).build();
  init();

  TraceContext parent = newTraceContext(SamplingFlags.SAMPLED);

  RpcContext.getContext().getAttachments().put("b3", B3SingleFormat.writeB3SingleFormat(parent));
  client.get().sayHello("jorge");

  MutableSpan span = testSpanHandler.takeRemoteSpan(SERVER);
  assertChildOf(span, parent);
  assertThat(span.id()).isNotEqualTo(parent.spanIdString());
}
 

@Override public TraceContextOrSamplingFlags extract(BinaryExtract binaryExtract) {
  try {
    return B3SingleFormat.parseB3SingleFormat(ascii.decode(binaryExtract.extractionBuffer()));
  } catch (RuntimeException e) {
    return TraceContextOrSamplingFlags.EMPTY;
  }
}
 

@Test public void createsChildWhenJoinDisabled() {
  tracing = tracingBuilder(NEVER_SAMPLE).supportsJoin(false).build();
  init();

  TraceContext parent = newTraceContext(SamplingFlags.SAMPLED);

  RpcContext.getContext().getAttachments().put("b3", B3SingleFormat.writeB3SingleFormat(parent));
  client.get().sayHello("jorge");

  assertChildOf(testSpanHandler.takeRemoteSpan(SERVER), parent);
}
 

@Test public void reusesPropagatedSpanId() {
  TraceContext parent = newTraceContext(SamplingFlags.SAMPLED);

  RpcContext.getContext().getAttachments().put("b3", B3SingleFormat.writeB3SingleFormat(parent));
  client.get().sayHello("jorge");

  assertSameIds(testSpanHandler.takeRemoteSpan(SERVER), parent);
}
 

@Test public void inject_field_multiple_key_names() {
  BaggageField userId = BaggageField.create("userId");
  BaggageField sessionId = BaggageField.create("sessionId");

  SingleBaggageField userIdConfig = SingleBaggageField.newBuilder(userId)
    .addKeyName("userId")
    .addKeyName("baggage-userId")
    .addKeyName("baggage_userId")
    .build();

  SingleBaggageField sessionIdConfig = SingleBaggageField.newBuilder(sessionId)
    .addKeyName("sessionId")
    .addKeyName("baggage-sessionId")
    .addKeyName("baggage_sessionId")
    .build();

  factory = newFactoryBuilder(B3SinglePropagation.FACTORY)
    .add(userIdConfig)
    .add(sessionIdConfig)
    .build();
  initialize();

  userId.updateValue(context, "bob");
  sessionId.updateValue(context, "12345");

  injector.inject(context, request);

  // NOTE: the labels are downcased
  assertThat(request).containsOnly(
    entry("b3", B3SingleFormat.writeB3SingleFormat(context)),
    entry("userid", "bob"),
    entry("sessionid", "12345"),
    entry("baggage-userid", "bob"),
    entry("baggage-sessionid", "12345"),
    entry("baggage_userid", "bob"),
    entry("baggage_sessionid", "12345")
  );
}
 

private void assertThatNewSpanIdWasSetOnMessage(String expectedSpanId) {
	Message<?> message = this.channel.receive(0);
	assertThat(message).as("message was null").isNotNull();

	String b3 = message.getHeaders().get("b3", String.class);
	// Trace and Span IDs are implicitly checked
	TraceContext extracted = B3SingleFormat.parseB3SingleFormat(b3).context();

	assertThat(extracted.spanIdString()).as("spanId was equal to parent's id")
			.isNotEqualTo(expectedSpanId);
}
 

private void assertThatNewSpanIdWasSetOnMessage(String expectedSpanId) {
	Message<?> message = this.channel.receive(0);
	assertThat(message).as("message was null").isNotNull();

	String b3 = message.getHeaders().get("b3", String.class);
	// Trace and Span IDs are implicitly checked
	TraceContext extracted = B3SingleFormat.parseB3SingleFormat(b3).context();

	assertThat(extracted.spanIdString()).as("spanId was equal to parent's id")
			.isNotEqualTo(expectedSpanId);
}
 

@RequestMapping(value = "/traceid", method = RequestMethod.GET)
public String traceId(@RequestHeader("b3") String b3Single) {
	TraceContextOrSamplingFlags traceContext = B3SingleFormat
			.parseB3SingleFormat(b3Single);
	then(traceContext.context()).isNotNull();
	return b3Single;
}
 

/** This shows that in practice, we don't report when the user tells us not to! */
@Test public void abandonedSpan() {
  TraceContext context = B3SingleFormat.parseB3SingleFormat(
      "50d980fffa300f29-86154a4ba6e91385-1"
  ).context();

  tracing.tracer().toSpan(context).name("test")
      .start(1L)
      .abandon(); // whoops.. don't need this one!

  triggerReport();

  assertThat(spans).isEmpty();
}
 

/** To reduce code, we don't use real client-server instrumentation. This fakes headers. */
static TraceContext fakeUseOfHeaders(TraceContext context) {
  return B3SingleFormat.parseB3SingleFormat(B3SingleFormat.writeB3SingleFormat(context))
    .context();
}
 

@Override public void run() {
  String expected = "1234567812345678-1234567812345678-1";
  String written =
    B3SingleFormat.writeB3SingleFormat(B3SingleFormat.parseB3SingleFormat(expected).context());
  if (!written.equals(expected)) throw new AssertionError();
}
 

@RequestMapping("/noresponse")
public void noResponse(@RequestHeader("b3") String b3Single) {
	TraceContextOrSamplingFlags traceContext = B3SingleFormat
			.parseB3SingleFormat(b3Single);
	then(traceContext.context()).isNotNull();
}
 

@Override public void inject(TraceContext traceContext, BinaryInject binaryInject) {
  byte[] injected = B3SingleFormat.writeB3SingleFormatAsBytes(traceContext);
  binaryInject.injectionBuffer(injected.length).put(injected);
}