public void startServerTracer(String contextPath) throws Exception { if (enabled) { submitEndpoint(contextPath); LOGGER.debug("Received no span state."); serverTracer.setStateUnknown(contextPath); serverTracer.setServerReceived(); } } public void submitEndpoint(String contextPath) throws Exception
public void handle(ServerResponseAdapter adapter) { // We can submit this in any case. When server state is not set or // we should not trace this request nothing will happen. LOGGER.fine("Sending server send."); try { for(KeyValueAnnotation annotation : adapter.responseAnnotations()) { serverTracer.submitBinaryAnnotation(annotation.getKey(), annotation.getValue()); } serverTracer.setServerSend(); } finally { serverTracer.clearCurrentSpan(); } } }
@Override public void stop(StopContext stopContext) { if (this.brave != null) { LOG.info("Shutdown Zipkin BTM services"); this.brave.serverTracer().setStateNoTracing(); } }
/** * Like {@link #setServerReceived()}, except you can log the network context of the caller, for * example an IP address from the {@code X-Forwarded-For} header. * * @param client represents the client (peer). Set {@link Endpoint#service_name} to * "unknown" if unknown. */ public void setServerReceived(Endpoint client) { submitAddress("ca", client); submitStartAnnotation("sr"); }
/** * Interface method implementation. Interprets the response for transport errors and submits suitable annotation to the server tracer and also marks receipt * of the response on it. * @see com.flipkart.phantom.task.spi.interceptor.ResponseInterceptor#process(java.lang.Object, com.google.common.base.Optional) */ public void process(S response, Optional<RuntimeException> transportError) { if (transportError.isPresent()) { this.serverTracer.submitAnnotation(FAILURE_ANNOTATION); } this.serverTracer.setServerSend(); }
/** * Sets the current Trace/Span state. Using this method indicates that we got no information about being part of an * existing trace or about the fact that we should not trace the current request. In this case the ServerTracer will * decide what to do. * * @param spanName The name of our current request/span. */ public void setStateUnknown(String spanName) { Span span = spanFactory().nextSpan(null); setStateCurrentTrace(span, spanName); }
serverTracer.clearCurrentSpan(); final TraceData traceData = adapter.getTraceData(); serverTracer.setStateNoTracing(); LOGGER.fine("Received indication that we should NOT trace."); } else { LOGGER.fine("Received span information as part of request."); SpanId spanId = traceData.getSpanId(); serverTracer.setStateCurrentTrace(spanId.traceId, spanId.spanId, spanId.nullableParentId(), adapter.getSpanName()); } else { LOGGER.fine("Received no span state."); serverTracer.setStateUnknown(adapter.getSpanName()); serverTracer.setServerReceived(); for(KeyValueAnnotation annotation : adapter.requestAnnotations()) serverTracer.submitBinaryAnnotation(annotation.getKey(), annotation.getValue());
serverTracer.clearCurrentSpan(); final TraceData traceData = adapter.getTraceData(); serverTracer.setStateNoTracing(); LOGGER.fine("Received indication that we should NOT trace."); return; LOGGER.fine("Received span information as part of request."); span = serverTracer.spanFactory().joinSpan(traceData.getSpanId()); } else { LOGGER.fine("Received no span state."); span = serverTracer.spanFactory().nextSpan(null); serverTracer.setStateNoTracing(); return; serverTracer.setStateCurrentTrace(span, adapter.getSpanName()); serverTracer.setServerReceived(); for(KeyValueAnnotation annotation : adapter.requestAnnotations()) serverTracer.submitBinaryAnnotation(annotation.getKey(), annotation.getValue());
private void beginTrace(final HttpServletRequest request) { if (!endPointSubmitter.endPointSubmitted()) { endPointSubmitter.submit(request.getLocalAddr(), request.getLocalPort(), getServiceName(request)); } final Optional<String> sampled = fromNullable(request.getHeader(BraveHttpHeaders.Sampled.getName())); if (!Boolean.valueOf(sampled.or(Boolean.TRUE.toString()))) { serverTracer.setStateNoTracing(); return; } updateServerState(request); serverTracer.setServerReceived(); }
@Test public void usesParentFromInvocationTime_server() throws Exception { server.enqueue(new MockResponse().setBodyDelay(1, TimeUnit.SECONDS)); server.enqueue(new MockResponse()); brave.serverTracer().setStateUnknown("test"); ServerSpan parent = brave.serverSpanThreadBinder().getCurrentServerSpan(); try { getAsync(client, "/foo"); getAsync(client, "/foo"); } finally { brave.serverTracer().clearCurrentSpan(); } // changing the server span after the fact! brave.serverTracer().setStateUnknown("test"); try { for (int i = 0; i < 2; i++) { RecordedRequest request = server.takeRequest(); assertThat(request.getHeader("x-b3-traceId")) .endsWith(IdConversion.convertToString(parent.getSpan().getTrace_id())); assertThat(request.getHeader("x-b3-parentspanid")) .endsWith(IdConversion.convertToString(parent.getSpan().getId())); } } finally { brave.serverTracer().clearCurrentSpan(); } }
@Override public void afterCompletion(final HttpServletRequest request, final HttpServletResponse response, final Object handler, final Exception ex) { final ServerSpan span = (ServerSpan) request.getAttribute(HTTP_SERVER_SPAN_ATTRIBUTE); if (span != null) { serverThreadBinder.setCurrentSpan(span); } try { serverTracer.setServerSend(); } finally { serverTracer.clearCurrentSpan(); } }
private void updateServerState(final HttpServletRequest request) { final Optional<Long> traceId = fromNullable(request.getHeader(BraveHttpHeaders.TraceId.getName())).transform(TO_HEX); final Optional<Long> spanId = fromNullable(request.getHeader(BraveHttpHeaders.SpanId.getName())).transform(TO_HEX); final String spanName = getSpanName(request.getHeader(BraveHttpHeaders.SpanName.getName()), request); if (traceId.isPresent() && spanId.isPresent()) { final Optional<Long> parentSpanId = fromNullable(request.getHeader(BraveHttpHeaders.ParentSpanId.getName())).transform(TO_HEX); serverTracer.setStateCurrentTrace(traceId.get(), spanId.get(), parentSpanId.orNull(), spanName); } else { serverTracer.setStateUnknown(spanName); } }
@Override public void afterCompletion(final HttpServletRequest request, final HttpServletResponse response, final Object handler, final Exception ex) { final ServerSpan span = (ServerSpan) request.getAttribute(HTTP_SERVER_SPAN_ATTRIBUTE); if (span != null) { serverThreadBinder.setCurrentSpan(span); } if (serverTracer != null && ex != null) { // TODO: revisit https://github.com/openzipkin/openzipkin.github.io/issues/52 String message = ex.getMessage(); if (message == null) message = ex.getClass().getSimpleName(); serverTracer.submitBinaryAnnotation("error", message); } responseInterceptor.handle(new HttpServerResponseAdapter(new HttpResponse() { // retrolambda fails to backport response::getStatus @Override public int getHttpStatusCode() { return response.getStatus(); // This won't work in Servlet 2.5 } })); } }
@Override public Collection<KeyValueAnnotation> requestAnnotations() { String ipAddr = RpcContext.getContext().getUrl().getIp(); InetSocketAddress inetSocketAddress = RpcContext.getContext().getRemoteAddress(); final String clientName = clientNameProvider.resolveClientName(RpcContext.getContext()); serverTracer.setServerReceived(IPConversion.convertToInt(ipAddr),inetSocketAddress.getPort(),clientName); InetSocketAddress socketAddress = RpcContext.getContext().getLocalAddress(); if (socketAddress != null) { KeyValueAnnotation remoteAddrAnnotation = KeyValueAnnotation.create("address", socketAddress.toString()); return Collections.singleton(remoteAddrAnnotation); } else { return Collections.emptyList(); } }
public void stopServerTracer() { if (enabled) { serverTracer.setServerSend(); } } public void startClientTracer(String clientContext)
/** * Sets the server sent event for current thread. */ public void setServerSend() { if (submitEndAnnotation(zipkinCoreConstants.SERVER_SEND, spanCollector())) { spanAndEndpoint().state().setCurrentServerSpan(null); } }
@Override public void afterConcurrentHandlingStarted(final HttpServletRequest request, final HttpServletResponse response, final Object handler) { request.setAttribute(HTTP_SERVER_SPAN_ATTRIBUTE, serverThreadBinder.getCurrentServerSpan()); serverTracer.clearCurrentSpan(); }
/** * @deprecated since 3.15 use {@link #setStateCurrentTrace(SpanId, String)} */ @Deprecated public void setStateCurrentTrace(long traceId, long spanId, @Nullable Long parentSpanId, String name) { SpanId context = SpanId.builder().traceId(traceId).spanId(spanId).parentId(parentSpanId).build(); setStateCurrentTrace(context, name); }
/** * Sets the server sent event for current thread. */ public void setServerSend() { if (submitEndAnnotation("ss")) { currentSpan().setCurrentSpan(ServerSpan.EMPTY); } }
/** * Interface method implementation. Sets up the ServerTrace current trace and submits the service enpoint details to EndPointSubmitter * @see com.flipkart.phantom.task.spi.interceptor.RequestInterceptor#process(com.flipkart.phantom.task.spi.RequestWrapper) */ public void process(T request) { this.endPointSubmitter.submit(this.serviceHost, this.servicePort, this.serviceName); TraceData traceData = getTraceDataFromHeaders(request); if (Boolean.FALSE.equals(traceData.shouldBeTraced())) { this.serverTracer.setStateNoTracing(); } else { String spanName = this.getSpanName(traceData, request); if (traceData.getTraceId() != null && traceData.getSpanId() != null) { this.serverTracer.setStateCurrentTrace(traceData.getTraceId(), traceData.getSpanId(), traceData.getParentSpanId(), spanName); } else { this.serverTracer.setStateUnknown(spanName); } } final Optional<String> requestMetadata = request.getRequestMetaData(); if (requestMetadata.isPresent()) { this.serverTracer.submitBinaryAnnotation(REQUEST_ANNOTATION, requestMetadata.get()); } this.serverTracer.setServerReceived(); }