Struct Span 

pub struct Span<T>
where
    T: SpanText,
{

    pub service: T,
    pub name: T,
    pub resource: T,
    pub type: T,
    pub trace_id: u128,
    pub span_id: u64,
    pub parent_id: u64,
    pub start: i64,
    pub duration: i64,
    pub error: i32,
    pub meta: HashMap<T, T>,
    pub metrics: HashMap<T, f64>,
    pub meta_struct: HashMap<T, Bytes>,
    pub span_links: Vec<SpanLink<T>>,
    pub span_events: Vec<SpanEvent<T>>,
}

The generic representation of a V04 span.

T is the type used to represent strings in the span, it can be either owned (e.g. BytesString) or borrowed (e.g. &str). To define a generic function taking any Span<T> you can use the [SpanValue] trait:

use libdd_trace_utils::span::{Span, SpanText};
fn foo<T: SpanText>(span: Span<T>) {
    let _ = span.meta.get("foo");
}

Fields

service: T

name: T

resource: T

type: T

trace_id: u128

span_id: u64

parent_id: u64

start: i64

duration: i64

error: i32

meta: HashMap<T, T>

metrics: HashMap<T, f64>

meta_struct: HashMap<T, Bytes>

span_links: Vec<SpanLink<T>>

span_events: Vec<SpanEvent<T>>

Implementations

impl Span<&str>

pub fn try_to_bytes(&self, bytes: &Bytes) -> Option<SpanBytes>

Converts a borrowed SpanSlice into an owned SpanBytes, by resolving all internal references into slices of the provided Bytes buffer. Returns None if any slice is out of bounds or invalid.

Trait Implementations

impl<T> Clone for Span<T>

where T: SpanText + Clone,

fn clone(&self) -> Span<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Span<T>

where T: SpanText + Debug,

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

Formats the value using the given formatter.

impl<T> Default for Span<T>

where T: SpanText + Default,

fn default() -> Span<T>

Returns the “default value” for a type.

impl<T> PartialEq for Span<T>

where T: SpanText + PartialEq,

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

where T: SpanText + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for Span<T>

where T: SpanText,