/** * Conditionally joins a span, or starts a new trace, depending on if a trace context was * extracted from the request. Tags are added before the span is started. * * <p>This is typically called before the request is processed by the actual library. */ public Span handleReceive(TraceContext.Extractor<Req> extractor, Req request) { return handleReceive(extractor, request, request); }
@SuppressWarnings("unchecked") HttpServerHandler<ServerHttpRequest, ServerHttpResponse> handler() { if (this.handler == null) { this.handler = HttpServerHandler.create( this.beanFactory.getBean(HttpTracing.class), new TraceWebFilter.HttpAdapter()); } return this.handler; }
@Override public void onComplete(AsyncEvent e) { if (complete) return; handler.handleSend(adaptResponse(e), null, span); complete = true; }
Span span = handler.handleReceive(extractor, httpRequest); servlet.handleAsync(handler, httpRequest, httpResponse, span); } else { // we have a synchronous response, so we can finish the span handler.handleSend(ADAPTER.adaptResponse(httpRequest, httpResponse), error, span);
protected TraceScopeHolder<TraceScope> startTraceSpan(final Map<String, List<String>> requestHeaders, URI uri, String method) { final Request request = HttpAdapterFactory.request(requestHeaders, uri, method); final HttpServerAdapter<Request, ?> adapter = HttpServerAdapterFactory.create(request); final HttpServerHandler<Request, ?> handler = HttpServerHandler.create(brave, adapter); Span span = handler.handleReceive( brave .tracing() .propagation() .extractor(adapter::requestHeader), request); // If the service resource is using asynchronous processing mode, the trace // scope will be closed in another thread and as such should be detached. SpanInScope scope = null; if (isAsyncResponse() && span != null) { // Do not modify the current context span propagateContinuationSpan(span); } else if (span != null) { scope = brave.tracing().tracer().withSpanInScope(span); } return new TraceScopeHolder<TraceScope>(new TraceScope(span, scope), scope == null /* detached */); }
final HttpServerAdapter<?, Response> adapter = HttpServerAdapterFactory.create(response); final HttpServerHandler<?, Response> handler = HttpServerHandler.create(brave, adapter); handler.handleSend(response, null, scope.getSpan()); } finally { scope.close();
public static <Req, Resp> HttpServerHandler<Req, Resp> create(HttpTracing httpTracing, HttpServerAdapter<Req, Resp> adapter) { return new HttpServerHandler<>(httpTracing, adapter); }
@Override public void handleRequest(HttpServerExchange exchange) throws Exception { if (!exchange.isComplete()) { Span span = serverHandler.handleReceive(extractor, exchange.getRequestHeaders(), exchange); exchange.addExchangeCompleteListener((exch, nextListener) -> { try { nextListener.proceed(); } finally { serverHandler.handleSend(exch, exch.getAttachment(ExceptionHandler.THROWABLE), span); } }); try (Scope scope = currentTraceContext.newScope(span.context())) { next.handleRequest(exchange); } catch (Exception | Error e) { // move the error to where the complete listener can see it exchange.putAttachment(ExceptionHandler.THROWABLE, e); throw e; } } else { next.handleRequest(exchange); } } }
protected TraceScopeHolder<TraceScope> startTraceSpan(final Map<String, List<String>> requestHeaders, URI uri, String method) { final Request request = HttpAdapterFactory.request(requestHeaders, uri, method); final HttpServerAdapter<Request, ?> adapter = HttpServerAdapterFactory.create(request); final HttpServerHandler<Request, ?> handler = HttpServerHandler.create(brave, adapter); Span span = handler.handleReceive( brave .tracing() .propagation() .extractor(adapter::requestHeader), request); // If the service resource is using asynchronous processing mode, the trace // scope will be closed in another thread and as such should be detached. SpanInScope scope = null; if (isAsyncResponse() && span != null) { // Do not modify the current context span propagateContinuationSpan(span); } else if (span != null) { scope = brave.tracing().tracer().withSpanInScope(span); } return new TraceScopeHolder<TraceScope>(new TraceScope(span, scope), scope == null /* detached */); }
final HttpServerAdapter<?, Response> adapter = HttpServerAdapterFactory.create(response); final HttpServerHandler<?, Response> handler = HttpServerHandler.create(brave, adapter); handler.handleSend(response, null, scope.getSpan()); } finally { scope.close();
@Override public void onError(AsyncEvent e) { if (complete) return; handler.handleSend(adaptResponse(e), e.getThrowable(), span); complete = true; }
TracePostZuulFilter(HttpTracing httpTracing) { this.handler = HttpServerHandler.create(httpTracing, new HttpServletAdapter()); this.tracer = httpTracing.tracing().tracer(); }
public Filter before() { return (request, response) -> { Span span = handler.handleReceive(extractor, request, request.raw()); request.attribute(Tracer.SpanInScope.class.getName(), tracer.withSpanInScope(span)); }; }
@Override public Object run() { if (log.isDebugEnabled()) { log.debug("Marking current span as handled"); } HttpServletResponse response = RequestContext.getCurrentContext().getResponse(); Throwable exception = RequestContext.getCurrentContext().getThrowable(); Span currentSpan = this.tracer.currentSpan(); this.handler.handleSend(response, exception, currentSpan); if (log.isDebugEnabled()) { log.debug("Handled send of " + currentSpan); } return null; }
@Inject TracingApplicationEventListener(HttpTracing httpTracing, EventParser parser) { tracer = httpTracing.tracing().tracer(); serverHandler = HttpServerHandler.create(httpTracing, new Adapter()); extractor = httpTracing.tracing().propagation().extractor(GETTER); this.parser = parser; }
@Override public RequestEventListener onRequest(RequestEvent requestEvent) { if (requestEvent.getType() == RequestEvent.Type.START) { Span span = serverHandler.handleReceive(extractor, requestEvent.getContainerRequest()); return new TracingRequestEventListener(span, tracer.withSpanInScope(span)); } return null; }
@Override public void onTimeout(AsyncEvent e) { if (complete) return; span.tag("error", String.format("Timed out after %sms", e.getAsyncContext().getTimeout())); handler.handleSend(adaptResponse(e), null, span); complete = true; }
SparkTracing(HttpTracing httpTracing) { // intentionally hidden constructor tracer = httpTracing.tracing().tracer(); handler = HttpServerHandler.create(httpTracing, ADAPTER); extractor = httpTracing.tracing().propagation().extractor(Request::headers); }
private Span findOrCreateSpan(Context c) { Span span; if (c.hasKey(Span.class)) { Span parent = c.get(Span.class); span = this.tracer .nextSpan(TraceContextOrSamplingFlags.create(parent.context())) .start(); if (log.isDebugEnabled()) { log.debug("Found span in reactor context" + span); } } else { if (this.attrSpan != null) { span = this.attrSpan; if (log.isDebugEnabled()) { log.debug("Found span in attribute " + span); } } else { span = this.handler.handleReceive(this.extractor, this.exchange.getRequest().getHeaders(), this.exchange.getRequest()); if (log.isDebugEnabled()) { log.debug("Handled receive of span " + span); } } this.exchange.getAttributes().put(TRACE_REQUEST_ATTR, span); } return span; }
public Filter afterAfter() { return (request, response) -> { Span span = tracer.currentSpan(); if (span == null) return; ((Tracer.SpanInScope) request.attribute(Tracer.SpanInScope.class.getName())).close(); handler.handleSend(ADAPTER.adaptResponse(request.raw(), response.raw()), null, span); }; }