Enum SamplingValue

pub enum SamplingValue {
    SampleRate {
        value: f64,
    },
    Factor {
        value: f64,
    },
    Reservoir {
        limit: i64,
    },
    MinimumSampleRate {
        value: f64,
    },
}

A sampling strategy definition.

A sampling strategy refers to the strategy that we want to use for sampling a specific rule.

Variants

SampleRate

A direct sample rate to apply.

A rule with a sample rate will be matched and the final sample rate will be computed by multiplying its sample rate with the accumulated factors from previous rules.

Fields

value: f64

The sample rate to apply to the rule.

Factor

A factor to apply on a subsequently matching rule.

A rule with a factor will be matched and the matching will continue onto the next rules until a sample rate rule is found. The matched rule’s factor will be multiplied with the accumulated factors before moving onto the next possible match.

Fields

value: f64

The factor to apply on another matched sample rate.

Reservoir

A reservoir limit.

A rule with a reservoir limit will be sampled if the rule have been matched fewer times than the limit.

Fields

limit: i64

The limit of how many times this rule will be sampled before this rule is invalid.

MinimumSampleRate

A minimum sample rate.

The sample rate specified in the rule will be used as a minimum over the otherwise used sample rate.

Only the first matching minimum sample rate will be applied.

Fields

value: f64

The minimum sample rate used to raise the chosen sample rate.

Trait Implementations

impl Clone for SamplingValue

fn clone(&self) -> SamplingValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SamplingValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SamplingValue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SamplingValue

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for SamplingValue

impl StructuralPartialEq for SamplingValue