@Override public BraveSpan error(Throwable throwable) { span.error(throwable); return this; }
@Override public void onException(JMSException exception) { Span span = tracer.currentSpan(); if (span != null) span.error(exception); } }
void onFailure(Span span, String log, boolean hasLog, Throwable e) { if (logger.isDebugEnabled()) { logger.debug("Exception occurred while trying to continue the pointcut", e); } if (hasLog) { logEvent(span, log + ".afterFailure"); } span.error(e); }
static void onError(Throwable error, Span span) { span.error(error); if (error instanceof RpcException) { span.tag("dubbo.error_code", Integer.toString(((RpcException) error).getCode())); } }
@Override public void onException(Message message, Exception exception) { try { delegate.onException(message, exception); span.error(exception); } finally { span.finish(); } } }
@Override public void onCompletion(RecordMetadata metadata, @Nullable Exception exception) { if (exception != null) span.error(exception); span.finish(); } }
@Override public void send(Message message) throws JMSException { Span span = createAndStartProducerSpan(null, message); SpanInScope ws = tracer.withSpanInScope(span); // animal-sniffer mistakes this for AutoCloseable try { delegate.send(message); } catch (RuntimeException | JMSException | Error e) { span.error(e); throw e; } finally { ws.close(); span.finish(); } }
@Override public void send(Message message, int deliveryMode, int priority, long timeToLive) throws JMSException { Span span = createAndStartProducerSpan(null, message); SpanInScope ws = tracer.withSpanInScope(span); // animal-sniffer mistakes this for AutoCloseable try { delegate.send(message, deliveryMode, priority, timeToLive); } catch (RuntimeException | JMSException | Error e) { span.error(e); throw e; } finally { ws.close(); span.finish(); } }
@Override public void close(Status status, Metadata trailers) { try { super.close(status, trailers); parser.onClose(status, trailers, span.customizer()); } catch (RuntimeException | Error e) { span.error(e); throw e; } finally { span.finish(); } } }
@JMS2_0 public void send(Message message, CompletionListener completionListener) throws JMSException { Span span = createAndStartProducerSpan(null, message); SpanInScope ws = tracer.withSpanInScope(span); // animal-sniffer mistakes this for AutoCloseable try { delegate.send(message, TracingCompletionListener.create(completionListener, span, current)); } catch (RuntimeException | JMSException | Error e) { span.error(e); span.finish(); throw e; } finally { ws.close(); } }
@Override public void onMessage(Message message) { Span listenerSpan = startMessageListenerSpan(message); try (SpanInScope ws = tracer.withSpanInScope(listenerSpan)) { delegate.onMessage(message); } catch (Throwable t) { listenerSpan.error(t); throw t; } finally { listenerSpan.finish(); } }
@JMS2_0 public void send(Message message, int deliveryMode, int priority, long timeToLive, CompletionListener completionListener) throws JMSException { Span span = createAndStartProducerSpan(null, message); completionListener = TracingCompletionListener.create(completionListener, span, current); SpanInScope ws = tracer.withSpanInScope(span); // animal-sniffer mistakes this for AutoCloseable try { delegate.send(message, deliveryMode, priority, timeToLive, completionListener); } catch (RuntimeException | JMSException | Error e) { span.error(e); span.finish(); throw e; } finally { ws.close(); } }
@Override public void onException(JMSException exception) { Span span = tracer.currentSpan(); if (span == null) { delegate.onException(exception); return; } try (SpanInScope ws = tracer.withSpanInScope(span)) { delegate.onException(exception); } finally { span.error(exception); } } }
@Override public void onHalfClose() { SpanInScope scope = tracer.withSpanInScope(span); try { // retrolambda can't resolve this try/finally delegate().onHalfClose(); } catch (RuntimeException | Error e) { // If there was an exception executing onHalfClose, we don't expect other lifecycle // commands to succeed. Accordingly, we close the span span.error(e); span.finish(); throw e; } finally { scope.close(); } }
void send(SendDestination sendDestination, Destination destination, Message message) throws JMSException { Span span = createAndStartProducerSpan(destination, message); SpanInScope ws = tracer.withSpanInScope(span); // animal-sniffer mistakes this for AutoCloseable try { sendDestination.apply(delegate, destination, message); } catch (RuntimeException | JMSException | Error e) { span.error(e); throw e; } finally { ws.close(); span.finish(); } }
@Override public void publish(Message message, int deliveryMode, int priority, long timeToLive) throws JMSException { checkTopicPublisher(); TopicPublisher tp = (TopicPublisher) delegate; Span span = createAndStartProducerSpan(null, message); SpanInScope ws = tracer.withSpanInScope(span); // animal-sniffer mistakes this for AutoCloseable try { tp.publish(message, deliveryMode, priority, timeToLive); } catch (RuntimeException | JMSException | Error e) { span.error(e); throw e; } finally { ws.close(); span.finish(); } }
@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 void onMessage(Message message, Session session) throws JMSException { Span span = this.jmsTracing.nextSpan(message).name("on-message").start(); try (CurrentTraceContext.Scope ws = this.current.newScope(span.context())) { super.onMessage(message, session); } catch (JMSException | RuntimeException | Error e) { span.error(e); 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(); } }