Enum SpanKind

pub enum SpanKind {
    Client,
    Server,
    Producer,
    Consumer,
    Internal,
}

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 Clone for SpanKind

fn clone(&self) -> SpanKind

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SpanKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for SpanKind

fn eq(&self, other: &SpanKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for SpanKind

impl StructuralPartialEq for SpanKind