Struct metrics_util::Recency

pub struct Recency<K> { /* fields omitted */ }

Tracks recency of metric updates by their registry generation and time.

In many cases, a user may have a long-running process where metrics are stored over time using labels that change for some particular reason, leaving behind versions of that metric with labels that are no longer relevant to the current process state. This can lead to cases where metrics that no longer matter are still present in rendered output, adding bloat.

When coupled with Registry, Recency can be used to track when the last update to a metric has occurred for the purposes of removing idle metrics from the registry. In addition, it will remove the value from the registry itself to reduce the aforementioned bloat.

Recency is separate from Registry specifically to avoid imposing any slowdowns when tracking recency does not matter, despite their otherwise tight coupling.

Implementations

impl<K> Recency<K>

pub fn new(
    clock: Clock,
    mask: MetricKindMask,
    idle_timeout: Option<Duration>
) -> Recency<K>

Creates a new Recency.

If idle_timeout is None, no recency checking will occur. mask controls which metrics are covered by the recency logic. For example, if mask only contains counters and histograms, then gauges will not be considered for recency, and thus will never be deleted.

If idle_timeout is not None, then metrics which have not been updated within the given duration will be subject to deletion when checked. Specifically, the deletions done by this object only happen when the object is “driven” by calling should_store, and so handles will not necessarily be deleted immediately after execeeding their idle timeout.

Refer to the documentation for MetricKindMask for more information on defining a metric kind mask.

pub fn should_store<H, G>(
    &self,
    kind: MetricKind,
    key: &K,
    gen: Generation,
    registry: &Registry<K, H, G>
) -> bool where
    K: Debug + Eq + Hashable + Clone + 'static,
    H: Debug + Clone + 'static,
    G: Generational<H>, 

Checks if the given key should be stored, based on its known recency.

kind will be used to see if the given metric kind is subject to recency tracking for this instance. generation should be obtained from the the same reference to registry that been given.

If the given key has been updated recently enough, and should continue to be stored, this method will return true and will update the last update time internally. If the given key has not been updated recently enough, the key will be removed from the given registry if the given generation also matches.

If the generation does not match, this indicates that the key was updated between querying it from the registry and calling this method, and this method will return true in those cases, and false for all remaining cases.

Trait Implementations

impl<K: Debug> Debug for Recency<K>

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

Formats the value using the given formatter.