Refine search
Span startMessageListenerSpan(Message message) { if (!addConsumerSpan) return jmsTracing.nextSpan(message).name("on-message").start(); TraceContextOrSamplingFlags extracted = jmsTracing.extractAndClearMessage(message); // JMS has no visibility of the incoming message, which incidentally could be local! Span consumerSpan = tracer.nextSpan(extracted).kind(CONSUMER).name("receive"); Span listenerSpan = tracer.newChild(consumerSpan.context()); if (!consumerSpan.isNoop()) { long timestamp = tracing.clock(consumerSpan.context()).currentTimeMicroseconds(); consumerSpan.start(timestamp); if (remoteServiceName != null) consumerSpan.remoteServiceName(remoteServiceName); jmsTracing.tagQueueOrTopic(message, consumerSpan); long consumerFinish = timestamp + 1L; // save a clock reading consumerSpan.finish(consumerFinish); // not using scoped span as we want to start late listenerSpan.name("on-message").start(consumerFinish); } return listenerSpan; } }
static void parseTargetAddress(HttpRequestWrapper httpRequest, Span span) { if (span.isNoop()) return; HttpHost target = httpRequest.getTarget(); if (target == null) return; InetAddress address = target.getAddress(); if (address != null) { if (span.remoteIpAndPort(address.getHostAddress(), target.getPort())) return; } span.remoteIpAndPort(target.getHostName(), target.getPort()); }
void setConsumerSpan(String topic, Span span) { span.name("poll").kind(Span.Kind.CONSUMER).tag(KafkaTags.KAFKA_TOPIC_TAG, topic); if (remoteServiceName != null) span.remoteServiceName(remoteServiceName); } }
@Override public void onMessage(Message message) { Span listenerSpan = startMessageListenerSpan(message); try (SpanInScope ws = tracer.withSpanInScope(listenerSpan)) { delegate.onMessage(message); } catch (Throwable t) { listenerSpan.error(t); throw t; } finally { listenerSpan.finish(); } }
/** * MethodInterceptor for {@link SimpleMessageListenerContainer.ContainerDelegate#invokeListener(Channel, * Message)} */ @Override public Object invoke(MethodInvocation methodInvocation) throws Throwable { Message message = (Message) methodInvocation.getArguments()[1]; TraceContextOrSamplingFlags extracted = springRabbitTracing.extractAndClearHeaders(message); // named for BlockingQueueConsumer.nextMessage, which we can't currently see Span consumerSpan = tracer.nextSpan(extracted); Span listenerSpan = tracer.newChild(consumerSpan.context()); if (!consumerSpan.isNoop()) { setConsumerSpan(consumerSpan, message.getMessageProperties()); // incur timestamp overhead only once long timestamp = tracing.clock(consumerSpan.context()).currentTimeMicroseconds(); consumerSpan.start(timestamp); long consumerFinish = timestamp + 1L; // save a clock reading consumerSpan.finish(consumerFinish); // not using scoped span as we want to start with a pre-configured time listenerSpan.name("on-message").start(consumerFinish); } try (SpanInScope ws = tracer.withSpanInScope(listenerSpan)) { return methodInvocation.proceed(); } catch (Throwable t) { listenerSpan.error(t); throw t; } finally { listenerSpan.finish(); } }
@Override public void process(K k, V v) { Span span = kafkaStreamsTracing.nextSpan(processorContext); if (!span.isNoop()) { span.name(spanName); span.start(); } try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) { delegateProcessor.process(k, v); } catch (RuntimeException | Error e) { span.error(e); // finish as an exception means the callback won't finish the span throw e; } finally { span.finish(); } }
TraceContextOrSamplingFlags extracted = this.extractor.extract(headers); Span consumerSpan = this.tracer.nextSpan(extracted); if (!consumerSpan.isNoop()) { consumerSpan.kind(Span.Kind.CONSUMER).start(); consumerSpan.remoteServiceName(REMOTE_SERVICE_NAME); addTags(message, consumerSpan, channel); consumerSpan.finish(); .next(TraceContextOrSamplingFlags.create(consumerSpan.context())) .name("handle").start(); this.tracing.propagation().keys()); if (log.isDebugEnabled()) { log.debug("Created a new span in before handle" + consumerSpan);
@RequestMapping("/traced") public String traced() throws InterruptedException { Span span = this.tracer.nextSpan().name("http:customTraceEndpoint").start(); int millis = this.random.nextInt(1000); log.info(String.format("Sleeping for [%d] millis", millis)); Thread.sleep(millis); this.tracer.currentSpan().tag("random-sleep-millis", String.valueOf(millis)); String s = this.restTemplate .getForObject("http://localhost:" + this.port + "/call", String.class); span.finish(); return "traced/" + s; }
/** * 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()); }
/** * Uses {@link ThreadLocalSpan} as there's no attribute namespace shared between callbacks, but * all callbacks happen on the same thread. * * <p>Uses {@link ThreadLocalSpan#CURRENT_TRACER} and this interceptor initializes before * tracing. */ @Override public <T extends Resultset> T preProcess(Supplier<String> sqlSupplier, Query interceptedQuery) { // Gets the next span (and places it in scope) so code between here and postProcess can read it Span span = ThreadLocalSpan.CURRENT_TRACER.next(); if (span == null || span.isNoop()) return null; String sql = sqlSupplier.get(); int spaceIndex = sql.indexOf(' '); // Allow span names of single-word statements like COMMIT span.kind(Span.Kind.CLIENT).name(spaceIndex == -1 ? sql : sql.substring(0, spaceIndex)); span.tag("sql.query", sql); parseServerIpAndPort(connection, span); span.start(); return null; }
if (records.isEmpty() || tracing.isNoop()) return records; long timestamp = 0L; Map<String, Span> consumerSpansForTopic = new LinkedHashMap<>(); Span span = consumerSpansForTopic.get(topic); if (span == null) { span = tracing.tracer().nextSpan(extracted); if (!span.isNoop()) { setConsumerSpan(topic, span); timestamp = tracing.clock(span.context()).currentTimeMicroseconds(); span.start(timestamp); injector.inject(span.context(), record.headers()); } else { // we extracted request-scoped data, so cannot share a consumer span. Span span = tracing.tracer().nextSpan(extracted); if (!span.isNoop()) { setConsumerSpan(topic, span); timestamp = tracing.clock(span.context()).currentTimeMicroseconds(); span.start(timestamp).finish(timestamp); // span won't be shared by other records injector.inject(span.context(), record.headers()); for (Span span : consumerSpansForTopic.values()) span.finish(timestamp); return records;
@WebMethod public Collection< Book > getBooks() { final Span span = brave.tracer().nextSpan().name("Get Books").start(); try (SpanInScope scope = brave.tracer().withSpanInScope(span)) { return Arrays.asList( new Book("Apache CXF in Action", UUID.randomUUID().toString()), new Book("Mastering Apache CXF", UUID.randomUUID().toString()) ); } finally { span.finish(); } }
@Override public void channelRead(ChannelHandlerContext ctx, Object msg) { if (!(msg instanceof HttpRequest)) { ctx.fireChannelRead(msg); // superclass does not throw return; } HttpRequest request = (HttpRequest) msg; Span span = nextSpan(extractor.extract(request.headers()), request).kind(Span.Kind.SERVER); ctx.channel().attr(NettyHttpTracing.SPAN_ATTRIBUTE).set(span); SpanInScope spanInScope = tracer.withSpanInScope(span); ctx.channel().attr(NettyHttpTracing.SPAN_IN_SCOPE_ATTRIBUTE).set(spanInScope); // Place the span in scope so that downstream code can read trace IDs try { if (!span.isNoop()) { parseChannelAddress(ctx, request, span); parser.request(adapter, request, span.customizer()); span.start(); } ctx.fireChannelRead(msg); spanInScope.close(); } catch (RuntimeException | Error e) { spanInScope.close(); span.error(e).finish(); // the request abended, so finish the span; throw e; } }
@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(); } }
@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); } }