Struct LabeledCounter 

pub struct LabeledCounter<L: LabelEnum> { /* private fields */ }

A counter indexed by an enum label, providing O(1) dimensional metrics.

Instead of using a HashMap to look up counters by label values, this type uses the enum variant’s index to directly access an array of counters. This eliminates hashing overhead on the hot path.

Example

use fast_telemetry::{LabeledCounter, LabelEnum};

#[derive(Copy, Clone, Debug)]
enum HttpMethod { Get, Post, Put, Delete, Other }

impl LabelEnum for HttpMethod {
    const CARDINALITY: usize = 5;
    const LABEL_NAME: &'static str = "method";

    fn as_index(self) -> usize { self as usize }
    fn from_index(index: usize) -> Self {
        match index {
            0 => Self::Get, 1 => Self::Post, 2 => Self::Put,
            3 => Self::Delete, _ => Self::Other,
        }
    }
    fn variant_name(self) -> &'static str {
        match self {
            Self::Get => "get", Self::Post => "post", Self::Put => "put",
            Self::Delete => "delete", Self::Other => "other",
        }
    }
}

let counter: LabeledCounter<HttpMethod> = LabeledCounter::new(4);
counter.inc(HttpMethod::Get);
counter.add(HttpMethod::Post, 5);

// Iteration for export
for (label, count) in counter.iter() {
    println!("{}={}: {}", HttpMethod::LABEL_NAME, label.variant_name(), count);
}

Implementations

impl<L: LabelEnum> LabeledCounter<L>

pub fn new(shard_count: usize) -> Self

Create a new labeled counter.

shard_count is passed to each underlying Counter for thread-sharding.

pub fn inc(&self, label: L)

Increment the counter for the given label by 1.

pub fn add(&self, label: L, value: isize)

Add a value to the counter for the given label.

pub fn get(&self, label: L) -> isize

Get the current count for a specific label.

pub fn sum_all(&self) -> isize

Get the sum across all labels.

pub fn iter(&self) -> impl Iterator<Item = (L, isize)> + '_

Iterate over all label/count pairs.

Used for Prometheus export.

pub fn swap_all(&self) -> impl Iterator<Item = (L, isize)> + '_

Swap all counters and return label/count pairs.

Useful for delta-style metrics export.

Trait Implementations

impl<L: LabelEnum> DogStatsDExport for LabeledCounter<L>

fn export_dogstatsd( &self, output: &mut String, name: &str, tags: &[(&str, &str)], )

Export this metric to the output string in DogStatsD format.

impl<L: LabelEnum> OtlpExport for LabeledCounter<L>

fn export_otlp( &self, metrics: &mut Vec<Metric>, name: &str, description: &str, time_unix_nano: u64, )

impl<L: LabelEnum> PrometheusExport for LabeledCounter<L>

fn export_prometheus(&self, output: &mut String, name: &str, help: &str)

Export this metric to the output string.