Enum tic::Interest

pub enum Interest<T> {
    AllanDeviation(T),
    Count(T),
    Gauge(T),
    LatencyPercentile(T),
    ValuePercentile(T),
    LatencyTrace(T, String),
    LatencyWaterfall(T, String),
    ValueTrace(T, String),
    ValueWaterfall(T, String),
}

an Interest registers a metric for reporting

Variants

AllanDeviation(T)

Calculate ADEV for the given metric based on the phase difference between start and stop of each Sample. NOTE: It is expected that there is 1 sample per second per metric

Count(T)

Keep a counter for the given metric, this is incremented by each count associated with a Sample

Gauge(T)

Keep a point-in-time value for the given metric, this is last-write-wins

LatencyPercentile(T)

Calculate latency percentiles for metric based on the delta between start and stop time for each Sample

ValuePercentile(T)

Calculate value percentiles for metric based on the counts associated with each Sample

LatencyTrace(T, String)

Creates a trace file of the latency heatmaps which store the delta between start and stop time for each Sample

LatencyWaterfall(T, String)

Generate a PNG plot of the latency heatmaps which store the delta between start and stop time for each Sample

ValueTrace(T, String)

Creates a trace file of the value heatmaps which store counts asccociated with each Sample

ValueWaterfall(T, String)

Generate a PNG plot of the value heatmaps which store counts asccociated with each Sample

Trait Implementations

impl<T: Clone> Clone for Interest<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Eq> Eq for Interest<T>

impl<T: Hash> Hash for Interest<T>

fn hash<__HT: Hasher>(&self, state: &mut __HT)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl<T: PartialEq> PartialEq for Interest<T>

fn eq(&self, other: &Interest<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Interest<T>) -> bool

This method tests for !=.