@Override public HttpTracing getObject() { HttpTracing.Builder builder = HttpTracing.newBuilder(tracing); if (clientParser != null) builder.clientParser(clientParser); if (serverParser != null) builder.serverParser(serverParser); if (clientSampler != null) builder.clientSampler(clientSampler); if (serverSampler != null) builder.serverSampler(serverSampler); return builder.build(); }
/** * Scopes this component for a client of the indicated server. * * @see #serverName() */ public HttpTracing clientOf(String serverName) { return toBuilder().serverName(serverName).build(); }
public static HttpTracing create(Tracing tracing) { return newBuilder(tracing).build(); }
/** * 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)); }
/** * 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); }
@Override public void onSuccess(ClientHttpResponse result) { handler.handleReceive(result, null, span); } }
/** * 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); }
/** Returns the span name of the request. Defaults to the http method. */ protected <Req> String spanName(HttpAdapter<Req, ?> adapter, Req req) { return adapter.method(req); }
/** * Like {@link #statusCode(Object)} except returns a primitive where zero implies absent. * * <p>Using this method usually avoids allocation, so is encouraged when parsing data. */ public int statusCodeAsInt(Resp response) { Integer maybeStatus = statusCode(response); return maybeStatus != null ? maybeStatus : 0; }
@Override void parseRequest(Req request, Span span) { span.kind(Span.Kind.SERVER); adapter.parseClientIpAndPort(request, span); parser.request(adapter, request, span.customizer()); }
/** * Customizes the span based on the request received from the client. * * <p>{@inheritDoc} */ @Override public <Req> void request(HttpAdapter<Req, ?> adapter, Req req, SpanCustomizer customizer) { super.request(adapter, req, customizer); }
public static <Req, Resp> HttpClientHandler<Req, Resp> create(HttpTracing httpTracing, HttpClientAdapter<Req, Resp> adapter) { return new HttpClientHandler<>(httpTracing, adapter); }
public static <Req, Resp> HttpServerHandler<Req, Resp> create(HttpTracing httpTracing, HttpServerAdapter<Req, Resp> adapter) { return new HttpServerHandler<>(httpTracing, adapter); }
public HttpTracing build() { return new HttpTracing(this); } }
public Builder toBuilder() { return new Builder(this); }
/** * 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); }
@Override public void onFailure(Throwable ex) { handler.handleReceive(null, ex, span); }
/** * Customizes the span based on the request that will be sent to the server. * * <p>{@inheritDoc} */ @Override public <Req> void request(HttpAdapter<Req, ?> adapter, Req req, SpanCustomizer customizer) { super.request(adapter, req, customizer); }
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); }