@Benchmark public void inject() { Map<String, String> carrier = new LinkedHashMap<>(); b3Injector.inject(context, carrier); }
@Benchmark public void inject() { Map<String, String> carrier = new LinkedHashMap<>(); b3Injector.inject(context, carrier); }
@Benchmark public void inject() { Map<String, String> carrier = new LinkedHashMap<>(); extraInjector.inject(context, carrier); }
@Override public void inject(TraceContext traceContext, C carrier) { delegate.inject(traceContext, carrier); Extra extra = traceContext.findExtra(Extra.class); if (extra == null) return; inject(extra, carrier); }
@Override public void accept(Propagation<?> propagation) { TraceContext.Injector<Map<Object, String>> injector = propagation.injector(Map::put); TraceContext.Extractor<Map<Object, String>> extractor = propagation.extractor(Map::get); TraceContext ctx = TraceContext.newBuilder().traceId(1L).spanId(2L).sampled(false).build(); Map<Object, String> map = new LinkedHashMap<>(); injector.inject(ctx, map); assertThat(extractor.extract(map).context()) .isEqualToIgnoringGivenFields(ctx, "traceIdString", "spanIdString"); } }
if (kind.equals(Kind.CLIENT)) { span = tracer.nextSpan(); injector.inject(span.context(), invocation.getAttachments()); } else { TraceContextOrSamplingFlags extracted = extractor.extract(invocation.getAttachments());
injector.inject(span.context(), record.headers());
/** * Starts and propagates {@link Span.Kind#PRODUCER} span for each message sent. */ @Override public Message<?> preSend(Message<?> message, MessageChannel channel) { if (emptyMessage(message)) { return message; } Message<?> retrievedMessage = getMessage(message); MessageHeaderAccessor headers = mutableHeaderAccessor(retrievedMessage); TraceContextOrSamplingFlags extracted = this.extractor.extract(headers); Span span = this.threadLocalSpan.next(extracted); MessageHeaderPropagation.removeAnyTraceHeaders(headers, this.tracing.propagation().keys()); this.injector.inject(span.context(), headers); if (!span.isNoop()) { span.kind(Span.Kind.PRODUCER).name("send").start(); span.remoteServiceName(REMOTE_SERVICE_NAME); addTags(message, span, channel); } if (log.isDebugEnabled()) { log.debug("Created a new span in pre send" + span); } Message<?> outputMessage = outputMessage(message, retrievedMessage, headers); if (isDirectChannel(channel)) { beforeHandle(outputMessage, channel, null); } return outputMessage; }
/** * This starts a consumer span as a child of the incoming message or the current trace * context, placing it in scope until the receive completes. */ @Override public Message<?> postReceive(Message<?> message, MessageChannel channel) { if (emptyMessage(message)) { return message; } MessageHeaderAccessor headers = mutableHeaderAccessor(message); TraceContextOrSamplingFlags extracted = this.extractor.extract(headers); Span span = this.threadLocalSpan.next(extracted); MessageHeaderPropagation.removeAnyTraceHeaders(headers, this.tracing.propagation().keys()); this.injector.inject(span.context(), headers); if (!span.isNoop()) { span.kind(Span.Kind.CONSUMER).name("receive").start(); span.remoteServiceName(REMOTE_SERVICE_NAME); addTags(message, span, channel); } if (log.isDebugEnabled()) { log.debug("Created a new span in post receive " + span); } headers.setImmutable(); return new GenericMessage<>(message.getPayload(), headers.getMessageHeaders()); }
@Override public Message postProcessMessage(Message message) { TraceContext maybeParent = currentTraceContext.get(); // Unlike message consumers, we try current span before trying extraction. This is the proper // order because the span in scope should take precedence over a potentially stale header entry. // // NOTE: Brave instrumentation used properly does not result in stale header entries, as we // always clear message headers after reading. Span span; if (maybeParent == null) { span = tracer.nextSpan(springRabbitTracing.extractAndClearHeaders(message)); } else { // If we have a span in scope assume headers were cleared before span = tracer.newChild(maybeParent); } if (!span.isNoop()) { span.kind(Span.Kind.PRODUCER).name("publish"); if (remoteServiceName != null) span.remoteServiceName(remoteServiceName); // incur timestamp overhead only once long timestamp = tracing.clock(span.context()).currentTimeMicroseconds(); span.start(timestamp).finish(timestamp); } injector.inject(span.context(), message.getMessageProperties()); return message; } }
@Override public HttpResponse execute(ClientRequestContext ctx, HttpRequest req) throws Exception { final Span span = tracer.nextSpan(); injector.inject(span.context(), req.headers()); // For no-op spans, we only need to inject into headers and don't set any other attributes. if (span.isNoop()) { return delegate().execute(ctx, req); } final String method = ctx.method().name(); span.kind(Kind.CLIENT).name(method); ctx.log().addListener(log -> SpanContextUtil.startSpan(span, log), RequestLogAvailability.REQUEST_START); // Ensure the trace context propagates to children ctx.onChild(RequestContextCurrentTraceContext::copy); ctx.log().addListener(log -> { SpanTags.logWireSend(span, log.requestFirstBytesTransferredTimeNanos(), log); SpanTags.logWireReceive(span, log.responseFirstBytesTransferredTimeNanos(), log); finishSpan(span, log); }, RequestLogAvailability.COMPLETE); try (SpanInScope ignored = tracer.withSpanInScope(span)) { return delegate().execute(ctx, req); } }
@Benchmark public void inject_b3() { Metadata carrier = new Metadata(); b3Injector.inject(context, carrier); }
@Benchmark public void inject_both_no_tags() { Metadata carrier = new Metadata(); bothInjector.inject(context, carrier); }
void verifyRoundTrip(TraceContextOrSamplingFlags expected) { TraceContextOrSamplingFlags extracted = propagation.extractor(mapEntry).extract(map); assertThat(extracted) .isEqualTo(expected); Map<K, String> injected = new LinkedHashMap<>(); if (expected.context() != null) { propagation.injector(mapEntry).inject(expected.context(), injected); } else { inject(injected, expected.samplingFlags()); } assertThat(map).isEqualTo(injected); }
@Benchmark public void inject_both() { Metadata carrier = new Metadata(); bothInjector.inject(contextWithTags, carrier); }
@Override public void accept(Propagation<?> propagation) { TraceContext.Injector<Map<Object, String>> injector = propagation.injector(Map::put); TraceContext.Extractor<Map<Object, String>> extractor = propagation.extractor(Map::get); TraceContext ctx = TraceContext.newBuilder().traceId(1L).spanId(2L).sampled(false).build(); Map<Object, String> map = new LinkedHashMap<>(); injector.inject(ctx, map); assertThat(extractor.extract(map).context()) .isEqualToIgnoringGivenFields(ctx, "traceIdString", "spanIdString"); } }
@Override public void inject(TraceContext traceContext, C carrier) { if (carrier instanceof Metadata) { byte[] serialized = TraceContextBinaryFormat.toBytes(traceContext); ((Metadata) carrier).put(GRPC_TRACE_BIN, serialized); Tags tags = traceContext.findExtra(Tags.class); if (tags != null) ((Metadata) carrier).put(GRPC_TAGS_BIN, tags.toMap()); } delegate.inject(traceContext, carrier); } }
@Override public void inject(TraceContext traceContext, C carrier) { delegate.inject(traceContext, carrier); Extra extra = traceContext.findExtra(Extra.class); if (extra == null) return; inject(extra, carrier); }
/** * Like {@link #handleSend(TraceContext.Injector, Object, Object)}, except explicitly controls the * span representing the request. * * @since 4.4 */ public <C> Span handleSend(TraceContext.Injector<C> injector, C carrier, Req request, Span span) { injector.inject(span.context(), carrier); return handleStart(request, span); }