Struct metrics_util::layers::FilterLayer

pub struct FilterLayer { /* fields omitted */ }

A layer for filtering and discarding metrics matching certain name patterns.

Uses an Aho-Corasick automaton to efficiently match a metric key against multiple patterns at once. Patterns are matched across the entire key i.e. they are matched as substrings.

If a metric key matches any of the configured patterns, it will be skipped entirely. This applies equally to metric registration and metric emission.

A number of options are exposed that control the underlying automaton, such as compilation to a DFA, or case sensitivity.

Implementations

impl FilterLayer

pub fn from_patterns<P, I>(patterns: P) -> Self where
    P: IntoIterator<Item = I>,
    I: AsRef<str>, 

Creates a FilterLayer from an existing set of patterns.

pub fn add_pattern<P>(&mut self, pattern: P) -> &mut FilterLayer where
    P: AsRef<str>, 

Adds a pattern to match.

pub fn case_insensitive(&mut self, case_insensitive: bool) -> &mut FilterLayer

Sets the case sensitivity used for pattern matching.

Defaults to false i.e. searches are case sensitive.

pub fn use_dfa(&mut self, dfa: bool) -> &mut FilterLayer

Sets whether or not to internally use a deterministic finite automaton.

The main benefit to a DFA is that it can execute searches more quickly than a NFA (perhaps 2-4 times as fast). The main drawback is that the DFA uses more space and can take much longer to build.

Enabling this option does not change the time complexity for constructing the underlying Aho-Corasick automaton (which is O(p) where p is the total number of patterns being compiled). Enabling this option does however reduce the time complexity of non-overlapping searches from O(n + p) to O(n), where n is the length of the haystack.

In general, it's a good idea to enable this if you're searching a small number of fairly short patterns (~1000), or if you want the fastest possible search without regard to compilation time or space usage.

Defaults to true.

Trait Implementations

impl Default for FilterLayer

fn default() -> FilterLayer

Returns the "default value" for a type.

impl<R> Layer<R> for FilterLayer

type Output = Filter<R>

The output type after wrapping.

fn layer(&self, inner: R) -> Self::Output

Wraps inner based on this layer.