static CompletionListener create(CompletionListener delegate, Span span, CurrentTraceContext current) { if (span.isNoop()) return delegate; // save allocation overhead return new TracingCompletionListener(delegate, span, current); }
private Span postProcessSpan(brave.Span span) { if (span == null || span.isNoop()) { return NoOpTracing.NoOpSpan.INSTANCE; } return new BraveSpan(span.kind(brave.Span.Kind.CLIENT), this.tracingOptions); } }
@Override public <T extends Resultset> T postProcess(Supplier<String> sql, Query interceptedQuery, T originalResultSet, ServerSession serverSession) { if (interceptingExceptions && originalResultSet == null) { // Error case, the span will be finished in TracingExceptionInterceptor. return null; } Span span = ThreadLocalSpan.CURRENT_TRACER.remove(); if (span == null || span.isNoop()) return null; span.finish(); return null; }
void finishSpan(Exception error) { Span span = this.threadLocalSpan.remove(); if (span == null || span.isNoop()) return; if (error != null) { // an error occurred, adding error to span String message = error.getMessage(); if (message == null) message = error.getClass().getSimpleName(); span.tag("error", message); } span.finish(); }
@Override public <T extends Resultset> T postProcess(String sql, Statement interceptedStatement, T originalResultSet, int warningCount, boolean noIndexUsed, boolean noGoodIndexUsed, Exception statementException) { Span span = ThreadLocalSpan.CURRENT_TRACER.remove(); if (span == null || span.isNoop()) return null; if (statementException instanceof SQLException) { span.tag("error", Integer.toString(((SQLException) statementException).getErrorCode())); } span.finish(); return null; }
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()); } }
@Override public ResultSetInternalMethods postProcess(String sql, Statement interceptedStatement, ResultSetInternalMethods originalResultSet, Connection connection, int warningCount, boolean noIndexUsed, boolean noGoodIndexUsed, SQLException statementException) { Span span = ThreadLocalSpan.CURRENT_TRACER.remove(); if (span == null || span.isNoop()) return null; if (statementException != null) { span.tag("error", Integer.toString(statementException.getErrorCode())); } span.finish(); return null; }
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()); }
@Override public void onAfterAnyExecute(StatementInformation info, long elapsed, SQLException e) { Span span = ThreadLocalSpan.CURRENT_TRACER.remove(); if (span == null || span.isNoop()) return; if (e != null) { span.tag("error", Integer.toString(e.getErrorCode())); } span.finish(); }
static void parseRouteAddress(Chain chain, Span span) { if (span.isNoop()) return; Connection connection = chain.connection(); if (connection == null) return; InetSocketAddress socketAddress = connection.route().socketAddress(); span.remoteIpAndPort(socketAddress.getHostString(), socketAddress.getPort()); }
static Callback create(@Nullable Callback delegate, Span span, CurrentTraceContext current) { if (span.isNoop()) return delegate; // save allocation overhead if (delegate == null) return new FinishSpan(span); return new DelegateAndFinishSpan(delegate, span, current); }
@Override void handleAsync(HttpServerHandler<HttpServletRequest, HttpServletResponse> handler, HttpServletRequest request, HttpServletResponse response, Span span) { if (span.isNoop()) return; // don't add overhead when we aren't httpTracing TracingAsyncListener listener = new TracingAsyncListener(handler, span); request.getAsyncContext().addListener(listener, request, response); }
Span handleStart(Req request, Span span) { if (span.isNoop()) return span; Scope ws = currentTraceContext.maybeScope(span.context()); try { parseRequest(request, span); } finally { ws.close(); } // all of the above parsing happened before a timestamp on the span return span.start(); }
Span nextSpan(ProcessorContext context) { TraceContextOrSamplingFlags extracted = extractor.extract(context.headers()); Span result = tracing.tracer().nextSpan(extracted); if (!result.isNoop()) { addTags(context, result); } return result; }
/** * Use this to create a span for processing the given record. Note: the result has no name and is * not started. * * <p>This creates a child from identifiers extracted from the record headers, or a new span if * one couldn't be extracted. */ public Span nextSpan(ConsumerRecord<?, ?> record) { TraceContextOrSamplingFlags extracted = extractAndClearHeaders(record.headers()); Span result = tracing.tracer().nextSpan(extracted); if (extracted.context() == null && !result.isNoop()) { addTags(record, result); } return result; }
@Override public VR transform(K k, V v) { Span span = kafkaStreamsTracing.nextSpan(processorContext); if (!span.isNoop()) { span.name(spanName); span.start(); } try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) { return delegateTransformer.transform(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(); } }
@Override public VR transform(V v) { Span span = kafkaStreamsTracing.nextSpan(processorContext); if (!span.isNoop()) { span.name(spanName); span.start(); } try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) { return delegateTransformer.transform(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(); } }
@Override public R transform(K k, V v) { Span span = kafkaStreamsTracing.nextSpan(processorContext); if (!span.isNoop()) { span.name(spanName); span.start(); } try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) { return delegateTransformer.transform(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(); } }
void handleFinish(@Nullable Resp response, @Nullable Throwable error, Span span) { if (span.isNoop()) return; try { Scope ws = currentTraceContext.maybeScope(span.context()); try { parser.response(adapter, response, error, span.customizer()); } finally { ws.close(); // close the scope before finishing the span } } finally { finishInNullScope(span); } }
void handleReceive(Message message) { if (message == null || tracing.isNoop()) return; // remove prior propagation headers from the message TraceContextOrSamplingFlags extracted = jmsTracing.extractAndClearMessage(message); Span span = tracer.nextSpan(extracted); if (!span.isNoop()) { span.name("receive").kind(Span.Kind.CONSUMER); Destination destination = destination(message); if (destination != null) jmsTracing.tagQueueOrTopic(destination, span); if (remoteServiceName != null) span.remoteServiceName(remoteServiceName); // incur timestamp overhead only once long timestamp = tracing.clock(span.context()).currentTimeMicroseconds(); span.start(timestamp).finish(timestamp); } jmsTracing.setNextParent(message, span.context()); }