Struct Sample

pub struct Sample<T: Ord + Zero + Copy> {
    pub dropped: usize,
    pub wraps: usize,
    pub p25: T,
    pub p50: T,
    pub p75: T,
    pub p90: T,
    pub p95: T,
    pub p99: T,
    pub p99p9: T,
    pub max: T,
    pub count: usize,
}

A sample of the state in Observations.

Fields

dropped: usize

Number of observations dropped due to lock contention

wraps: usize

Number of times the observation window wrapped around

p25: T

25th percentile observation

p50: T

50th percentile observation

p75: T

75th percentile observation

p90: T

90th percentile observation

p95: T

95th percentile observation

p99: T

99th percentile observation

p99p9: T

99.9th percentile observation

max: T

Maximum observation

count: usize

Number of observations

Implementations

impl<T: Ord + Zero + Copy + Into<i64>> Sample<T>

pub fn as_bucket_pairs(&self) -> Vec<(TimingBucket, i64)>

Returns each member of the struct along with its TimingBucket label. Each percentile is given as an i64.

pub fn dropped(&self) -> usize

Returns the number of observations dropped due to the observation lock being held.

pub fn wraps(&self) -> usize

Returns the number of times the observation count exceeded the available window size.

Trait Implementations

impl<T: Debug + Ord + Zero + Copy> Debug for Sample<T>

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

Formats the value using the given formatter.

impl<T: PartialEq + Ord + Zero + Copy> PartialEq for Sample<T>

fn eq(&self, other: &Sample<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: Eq + Ord + Zero + Copy> Eq for Sample<T>

impl<T: Ord + Zero + Copy> StructuralPartialEq for Sample<T>