/** * Like {@link #handleSend(TraceContext.Injector, Object)}, except explicitly controls the span * representing the request. * * @since 4.4 */ public Span handleSend(TraceContext.Injector<Req> injector, Req request, Span span) { return handleSend(injector, request, request, span); }
/** * Starts the client span after assigning it a name and tags. This {@link * TraceContext.Injector#inject(TraceContext, Object) injects} the trace context onto the request * before returning. * * <p>Call this before sending the request on the wire. */ public Span handleSend(TraceContext.Injector<Req> injector, Req request) { return handleSend(injector, request, request); }
Span handleSend(Map<String, Collection<String>> headers, Request request, Span clientSpan) { if (clientSpan != null) { return this.handler.handleSend(this.injector, headers, request, clientSpan); } return this.handler.handleSend(this.injector, headers, request); }
/** * Like {@link #handleSend(TraceContext.Injector, Object)}, except for when the carrier of trace * data is not the same as the request. * * @see HttpClientParser#request(HttpAdapter, Object, SpanCustomizer) */ public <C> Span handleSend(TraceContext.Injector<C> injector, C carrier, Req request) { return handleSend(injector, carrier, request, nextSpan(request)); }
private Span findOrCreateSpan(ClientRequest.Builder builder) { if (log.isDebugEnabled()) { log.debug("Instrumenting WebClient call"); } Span clientSpan = this.handler.handleSend(this.injector, builder, this.request, this.tracer.nextSpan()); if (log.isDebugEnabled()) { log.debug("Handled send of " + clientSpan); } return clientSpan; }
@Override public Response intercept(Chain chain) throws IOException { Request request = chain.request(); Request.Builder requestBuilder = request.newBuilder(); Span span = handler.handleSend(injector, requestBuilder, request); parseRouteAddress(chain, span); Response response = null; Throwable error = null; try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) { return response = chain.proceed(requestBuilder.build()); } catch (IOException | RuntimeException | Error e) { error = e; throw e; } finally { handler.handleReceive(response, error, span); } }
@Override public void filter(ClientRequestContext request) { Span span = handler.handleSend(injector, request.getHeaders(), request); request.setProperty(SpanInScope.class.getName(), tracer.withSpanInScope(span)); }
@Override public CloseableHttpResponse execute(HttpRoute route, HttpRequestWrapper request, HttpClientContext context, HttpExecutionAware execAware) throws IOException, HttpException { Span span = tracer.currentSpan(); if (span != null) { HttpAdapter.parseTargetAddress(request, span); handler.handleSend(injector, request, span); } return mainExec.execute(route, request, context, execAware); } }
@Override public void accept(HttpClientRequest req, Connection connection) { if (this.propagation.keys().stream() .anyMatch(key -> req.requestHeaders().contains(key))) { // request already instrumented return; } AtomicReference reference = req.currentContext() .getOrDefault(AtomicReference.class, new AtomicReference()); Span span = this.handler.handleSend(this.injector, req.requestHeaders(), req, (Span) reference.get()); reference.set(span); }
@Override public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException { Span span = handler.handleSend(injector, request.getHeaders(), request); ClientHttpResponse response = null; Throwable error = null; try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) { return response = execution.execute(request, body); } catch (IOException | RuntimeException | Error e) { error = e; throw e; } finally { handler.handleReceive(response, error, span); } }
@Override public void process(HttpRequest request, HttpContext context) { HttpHost host = HttpClientContext.adapt(context).getTargetHost(); TraceContext parent = (TraceContext) context.getAttribute(TraceContext.class.getName()); Span span; try (Scope scope = currentTraceContext.maybeScope(parent)) { span = handler.nextSpan(request); } HttpRequestWrapper requestWrapper = HttpRequestWrapper.wrap(request, host); parseTargetAddress(requestWrapper, span); handler.handleSend(injector, request, requestWrapper, span); context.setAttribute(Span.class.getName(), span); context.setAttribute(Scope.class.getName(), currentTraceContext.newScope(span.context())); } }
@Override public HttpHeaders filter(HttpHeaders input, ServerWebExchange exchange) { if (log.isDebugEnabled()) { log.debug("Will instrument the HTTP request headers"); } ServerHttpRequest.Builder builder = exchange.getRequest().mutate(); Span span = this.handler.handleSend(this.injector, builder); if (log.isDebugEnabled()) { log.debug( "Client span " + span + " created for the request. New headers are " + builder.build().getHeaders().toSingleValueMap()); } exchange.getAttributes().put(SPAN_ATTRIBUTE, span); HttpHeaders headersWithInput = new HttpHeaders(); headersWithInput.setAll(input.toSingleValueMap()); headersWithInput.setAll(builder.build().getHeaders().toSingleValueMap()); return headersWithInput; }
@Override public ListenableFuture<ClientHttpResponse> intercept(HttpRequest request, byte[] body, AsyncClientHttpRequestExecution execution) throws IOException { Span span = handler.handleSend(injector, request.getHeaders(), request); try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) { ListenableFuture<ClientHttpResponse> result = execution.executeAsync(request, body); result.addCallback(new TraceListenableFutureCallback(span, handler)); return result; } catch (IOException | RuntimeException | Error e) { handler.handleReceive(null, e, span); throw e; } }
@Override public Span createSpan(Invocation invocation) { return handler.handleSend(injector, invocation); }
@Override public ZuulFilterResult runFilter() { RequestContext ctx = RequestContext.getCurrentContext(); Span span = clientHandler.handleSend(injector, ctx); saveHeadersAsInvocationContext(ctx, span); SpanInScope scope = tracer.withSpanInScope(span); log.debug("Generated tracing span {} for {}", span, ctx.getRequest().getMethod()); ctx.getRequest().setAttribute(SpanInScope.class.getName(), scope); ZuulFilterResult result = super.runFilter(); log.debug("Result of Zuul filter is [{}]", result.getStatus()); if (ExecutionStatus.SUCCESS != result.getStatus()) { log.debug("The result of Zuul filter execution was not successful thus will close the current span {}", span); clientHandler.handleReceive(ctx.getResponse(), result.getException(), span); scope.close(); } return result; }
Span handleSend(Map<String, Collection<String>> headers, Request request, Span clientSpan) { if (clientSpan != null) { return this.handler.handleSend(this.injector, headers, request, clientSpan); } return this.handler.handleSend(this.injector, headers, request); }
@Override public Span createSpan(Invocation invocation) { return handler.handleSend(injector, invocation); }
@Override public Span createSpan(Invocation invocation) { return handler.handleSend(injector, invocation); }
private Span findOrCreateSpan(ClientRequest.Builder builder) { if (log.isDebugEnabled()) { log.debug("Instrumenting WebClient call"); } Span clientSpan = this.handler.handleSend(this.injector, builder, this.request, this.tracer.nextSpan()); if (log.isDebugEnabled()) { log.debug("Handled send of " + clientSpan); } return clientSpan; }
@Override public CloseableHttpResponse execute(HttpRoute route, HttpRequestWrapper request, HttpClientContext context, HttpExecutionAware execAware) throws IOException, HttpException { Span span = tracer.currentSpan(); if (span != null) { HttpAdapter.parseTargetAddress(request, span); handler.handleSend(injector, request, span); } return mainExec.execute(route, request, context, execAware); } }