Struct Span

pub struct Span {
    pub trace_id: TraceId,
    pub span_id: SpanId,
    pub operation_name: String,
    pub references: Vec<Reference>,
    pub start_time: i64,
    pub duration: i64,
    pub tags: Vec<Tag>,
    pub logs: Vec<Log>,
    pub process_id: String,
    pub warnings: Option<Vec<String>>,
}

Individual span within a distributed trace.

A span represents a single operation within a trace, containing timing information, metadata, references to other spans, and associated process information.

Fields

trace_id: TraceId

The trace ID this span belongs to

span_id: SpanId

Unique identifier for this span

operation_name: String

Human-readable name of the operation this span represents

references: Vec<Reference>

References to other spans (e.g., parent-child relationships)

start_time: i64

Timestamp when this span started (in microseconds since epoch)

duration: i64

Duration of this span in microseconds

tags: Vec<Tag>

Key-value tags providing metadata about this span

logs: Vec<Log>

Log entries recorded during this span’s execution

process_id: String

ID of the process that created this span

warnings: Option<Vec<String>>

Any warnings associated with this span

Implementations

impl Span

pub fn find_reference(&self, ref_type: &str) -> Option<&Reference>

Finds a reference of the specified type within this span.

Arguments

• ref_type - The type of reference to search for (e.g., “CHILD_OF”, “FOLLOWS_FROM”)

Returns

The first reference found with the matching type, or None if not found

pub fn get_parent_reference(&self) -> Option<&Reference>

Gets the parent reference for this span.

This is a convenience method that specifically looks for a “CHILD_OF” reference, which indicates the parent span in the trace hierarchy.

Returns

The parent reference if this span has one, or None if this is a root span

Example

use telemetry_rust::test::jaegar::Span;
use telemetry_rust::test::{SpanId, TraceId};

// Example of using get_parent_reference in span verification:
fn verify_parent_relationship(
    span: &Span,
    expected_trace_id: TraceId,
    expected_parent_span_id: SpanId,
) {
    let parent_reference = span.get_parent_reference().unwrap();
    assert_eq!(parent_reference.trace_id, expected_trace_id);
    assert_eq!(parent_reference.span_id, expected_parent_span_id);
}

Trait Implementations

impl Clone for Span

fn clone(&self) -> Span

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Span

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Span

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Span

fn eq(&self, other: &Span) -> 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 Serialize for Span

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Span