Enum opentelemetry::trace::SpanKind
source · pub enum SpanKind {
Client,
Server,
Producer,
Consumer,
Internal,
}
Expand description
SpanKind
describes the relationship between the Span
, its parents, and
its children in a trace.
SpanKind
describes two independent properties that benefit tracing systems
during analysis:
The first property described by SpanKind
reflects whether the span is a
“logical” remote child or parent. By “logical”, we mean that the span is
logically a remote child or parent, from the point of view of the library
that is being instrumented. Spans with a remote parent are interesting
because they are sources of external load. Spans with a remote child are
interesting because they reflect a non-local system dependency.
The second property described by SpanKind
reflects whether a child span
represents a synchronous call. When a child span is synchronous, the parent
is expected to wait for it to complete under ordinary circumstances. It can
be useful for tracing systems to know this property, since synchronous spans
may contribute to the overall trace latency. Asynchronous scenarios can be
remote or local.
In order for SpanKind
to be meaningful, callers should arrange that a
single span does not serve more than one purpose. For example, a server-side
span should not be used directly as the parent of another remote span. As a
simple guideline, instrumentation should create a new span prior to
extracting and serializing the SpanContext for a remote call.
Note: there are complex scenarios where a SpanKind::Client
span may have a
child that is also logically a SpanKind::Client
span, or a
SpanKind::Producer
span might have a local child that is a
SpanKind::Client
span, depending on how the various libraries that are
providing the functionality are built and instrumented. These scenarios,
when they occur, should be detailed in the semantic conventions appropriate
to the relevant libraries.
To summarize the interpretation of these kinds:
SpanKind | Synchronous | Asynchronous | Remote Incoming | Remote Outgoing |
---|---|---|---|---|
Client | yes | yes | ||
Server | yes | yes | ||
Producer | yes | maybe | ||
Consumer | yes | maybe | ||
Internal |
Variants§
Client
Indicates that the span describes a request to some remote service. This
span is usually the parent of a remote SpanKind::Server
span and does
not end until the response is received.
Server
Indicates that the span covers server-side handling of a synchronous RPC
or other remote request. This span is often the child of a remote
SpanKind::Client
span that was expected to wait for a response.
Producer
Indicates that the span describes the initiators of an asynchronous
request. This parent span will often end before the corresponding child
SpanKind::Consumer
span, possibly even before the child span starts.
In messaging scenarios with batching, tracing individual messages
requires a new SpanKind::Producer
span per message to be created.
Consumer
Indicates that the span describes a child of an asynchronous
SpanKind::Producer
request.
Internal
Default value.
Indicates that the span represents an internal operation within an application, as opposed to an operations with remote parents or children.
Trait Implementations§
impl Eq for SpanKind
impl StructuralPartialEq for SpanKind
Auto Trait Implementations§
impl Freeze for SpanKind
impl RefUnwindSafe for SpanKind
impl Send for SpanKind
impl Sync for SpanKind
impl Unpin for SpanKind
impl UnwindSafe for SpanKind
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)