Struct opentracingrust::Span

pub struct Span { /* fields omitted */ }

Model of an in progress operation.

A Span is to a distributed trace what a stack frame is to a stack trace.

Spans are created by Tracers with Tracer::span. Spans can be populated with StartOptions passed to Tracer::span and with the mutating methods described below.

Once an operation is complete the span should be finished with Span::finished.

Methods

impl Span

pub fn new(
    name: &str,
    context: SpanContext,
    options: StartOptions,
    sender: SpanSender
) -> Span

Creates a new Span instance and initialises any passed StartOptions.

This function is for use by TracerInterface implementations in their TracerInterface::span method.

The sender argument is the sending end of an crossbeam_channel::unbounded. The receiving end of this channel, usually returned by the tracer's initialisation routine, will gather FinishedSpans so they can be shipped to the distributed tracer.

impl Span

pub fn auto_finish(self) -> AutoFinishingSpan

Convert the running Span into an AutoFinishingSpan.

Spans instances need to be finished for the information to be sent. If a Span goes out of scope the information in it is lost and the span is never sent to the distributed tracer.

The AutoFinishingSpan wrapper allows a Span to be finished when it goes out of scope.

Panics

While this function never panics, keep in mind that the AutoFinishingSpan panics if Span::finish fails.

pub fn child_of(&mut self, parent: SpanContext)

Marks this span as a child of the given context.

pub fn context(&self) -> &SpanContext

Access the SpanContext of this span.

pub fn finish_time(&mut self, finish_time: SystemTime)

Set the span finish time.

This method allows to set the finish time of an operation explicitly and still manipulate the span further. This allows to time the operation first and the populate the span with any available detail without obfuscating the duration of the real operation.

pub fn finish(self) -> Result<()>

Finished a span and sends it to the tracer's receiver..

Consumes a Span to create a FinishedSpan. The finished span is then send to the tracer's crossbeam_channel::Receiver associated with the span at the time of creation.

Any error sending the span is returned to the caller.

pub fn follows(&mut self, parent: SpanContext)

Marks this span as a follower of the given context.

pub fn get_baggage_item(&self, key: &str) -> Option<&String>

Attempt to fetch a baggage item by key.

If there is no item with the given key this method returns None.

pub fn log(&mut self, log: Log)

Attach a log event to the span.

pub fn operation_name(&self) -> &str

Returns the operation name.

pub fn reference_span(&mut self, reference: SpanReference)

Adds a reference to a SpanContext.

pub fn references(&self) -> &[SpanReference]

Access all referenced span contexts and their relationship.

pub fn set_baggage_item(&mut self, key: &str, value: &str)

Adds or updates the baggage items with the given key/value pair.

Baggage items are forwarded to Spans that reference this Span and all the Spans that reference them.

Baggage items are NOT propagated backwards to Spans that reference this Span.

pub fn set_operation_name(&mut self, name: &str)

Updates the operation name.

pub fn tag<TV: Into<TagValue>>(&mut self, tag: &str, value: TV)

Append a tag to the span.

Examples

extern crate opentracingrust;

use opentracingrust::tracers::NoopTracer;


fn main() {
    let (tracer, _) = NoopTracer::new();
    let mut span = tracer.span("some_work");
    span.tag("client.name", "some-tracing-client");
    span.tag("client.version", 3.4);
    // ... snip ...
}

Trait Implementations

impl AsMut<Span> for AutoFinishingSpan

fn as_mut(&mut self) -> &mut Span

Performs the conversion.

impl AsMut<Span> for Span

fn as_mut(&mut self) -> &mut Span

Performs the conversion.

impl Debug for Span

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.