Span (Axon Framework 4.7.0 API)

All Known Implementing Classes:

OpenTelemetrySpan
```
public interface Span
```
Represents a part of the application logic that will be traced. One or multiple spans together form a trace and are often used to debug and monitor (distributed) applications.
The Span is an abstraction for Axon Framework to have tracing capabilities without knowing the specific tracing provider. Calling start() will start the span and make it active to the current thread. For every start invocation, a respective end() should be called as well to prevent scope leaks.
Creating spans is the responsibility of the SpanFactory which should be implemented by the tracing provider of choice.

Since:

4.6.0

Author:

Mitchell Herrijgers

See Also:

For more information about creating different kinds of traces.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`void`	`end()` Ends the span.
`Span`	`recordException(Throwable t)` Records an exception to the span.
`default void`	`run(Runnable runnable)` Runs a piece of code which will be traced.
`default <T> T`	`runCallable(Callable<T> callable)` Runs a piece of code which will be traced.
`default <T> T`	`runSupplier(Supplier<T> supplier)` Runs a piece of code that returns a value and which will be traced.
`Span`	`start()` Starts the Span.
`default <T> Callable<T>`	`wrapCallable(Callable<T> callable)` Wraps a `Callable`, propagating the current span context to the actual thread that runs the `Callable`.
`default Runnable`	`wrapRunnable(Runnable runnable)` Wraps a `Runnable`, propagating the current span context to the actual thread that runs the `Runnable`.
`default <T> Supplier<T>`	`wrapSupplier(Supplier<T> supplier)` Wraps a `Supplier`, tracing the invocation.

- Method Detail
  - start
```
Span start()
```
    Starts the Span. This means setting this span to the current, taking over from any active span currently present if so.
    
    Returns:
    
    The span for fluent interfacing.
  - end
```
void end()
```
    Ends the span. It restores the original context, often the parent trace, as the current context. No operation on the span is possible after this method.
  - recordException
```
Span recordException(Throwable t)
```
    Records an exception to the span. This will be reported to the APM tooling, which can show more information about the error in the trace. This method does not end the span.
    
    Parameters:
    
    t - The exception to record
    
    Returns:
    
    The span for fluent interfacing.
  - run
```
default void run(Runnable runnable)
```
    Runs a piece of code which will be traced. Exceptions will be caught automatically and added to the span, then rethrown. The span will be started before the execution, and ended after execution. Note that the Runnable will be invoked instantly and synchronously.
    
    Parameters:
    
    runnable - The Runnable to execute.
  - wrapRunnable
```
default Runnable wrapRunnable(Runnable runnable)
```
    Wraps a Runnable, propagating the current span context to the actual thread that runs the Runnable. If you don't wrap a runnable before passing it to an Executor the context will be lost and a new trace will be started.
    
    Parameters:
    
    runnable - The Runnable to wrap
    
    Returns:
    
    A wrapped runnable which propagates the span's context across threads.
  - runCallable
```
default <T> T runCallable(Callable<T> callable)
                   throws Exception
```
    Runs a piece of code which will be traced. Exceptions will be caught automatically and added to the span, then rethrown. The span will be started before the execution, and ended after execution. Note that the Callable will be invoked instantly and synchronously.
    
    Parameters:
    
    callable - The Callable to execute.
    
    Throws:
    
    Exception
  - wrapCallable
```
default <T> Callable<T> wrapCallable(Callable<T> callable)
```
    Wraps a Callable, propagating the current span context to the actual thread that runs the Callable. If you don't wrap a callable before passing it to an Executor the context will be lost and a new trace will be started.
    
    Parameters:
    
    callable - The Callable to wrap
    
    Returns:
    
    A wrapped callable which propagates the span's context across threads.
  - runSupplier
```
default <T> T runSupplier(Supplier<T> supplier)
```
    Runs a piece of code that returns a value and which will be traced. Exceptions will be caught automatically and added to the span, then rethrown. The span will be started before the execution, and ended after execution. Note that the Supplier will be invoked instantly and synchronously.
    
    Parameters:
    
    supplier - The Supplier to execute.
  - wrapSupplier
```
default <T> Supplier<T> wrapSupplier(Supplier<T> supplier)
```
    Wraps a Supplier, tracing the invocation. Exceptions will be caught automatically and added to the span, then rethrown. The span will be started before the execution, and ended after execution.
    
    Parameters:
    
    supplier - The Supplier to wrap
    
    Returns:
    
    A wrapped Supplier

Interface Span

Method Summary

Method Detail

start

end

recordException

run

wrapRunnable

runCallable

wrapCallable

runSupplier

wrapSupplier