Struct TraceData 

pub struct TraceData {
    pub trace_id: TraceId,
    pub spans: Vec<Span>,
    pub processes: HashMap<String, Process>,
    pub warnings: Option<Vec<String>>,
}

Complete trace data for a single distributed trace.

This structure contains all the information for a complete trace, including all spans that are part of the trace, process information, and any warnings that occurred during trace collection.

Fields

trace_id: TraceId

The unique identifier for this trace

spans: Vec<Span>

All spans that belong to this trace

processes: HashMap<String, Process>

Process information mapped by process ID

warnings: Option<Vec<String>>

Any warnings generated during trace collection

Implementations

impl TraceData

pub fn find_span(&self, operation_name: &str) -> Option<&Span>

Finds a span within this trace by its operation name.

Arguments

• operation_name - The name of the operation to search for

Returns

The first span found with the matching operation name, or None if not found

Example

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

fn verify_span<'td>(
    trace_data: &'td TraceData,
    operation_name: &str,
    trace_id: TraceId,
    parent_span_id: SpanId,
    service_name: &str,
) -> Option<&'td Span> {
    let span = trace_data.find_span(operation_name)?;

    assert_eq!(span.trace_id, trace_id);

    let parent_reference = span.get_parent_reference().unwrap();
    let process_id = &span.process_id;

    assert_eq!(parent_reference.trace_id, trace_id);
    assert_eq!(parent_reference.span_id, parent_span_id);

    let main_process = trace_data.processes.get(process_id).unwrap();
    assert_eq!(main_process.service_name, service_name);

    Some(span)
}

Trait Implementations

impl Clone for TraceData

fn clone(&self) -> TraceData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TraceData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TraceData

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TraceData

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

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 TraceData