Struct prometheus_client::metrics::counter::Counter

pub struct Counter<N = u64, A = AtomicU64> { /* private fields */ }

Open Metrics Counter to measure discrete events.

Single monotonically increasing value metric.

Counter is generic over the actual data type tracking the Counter state as well as the data type used to interact with the Counter. Out of convenience the generic type parameters are set to use an AtomicU64 as a storage and u64 on the interface by default.

Examples

Using AtomicU64 as storage and u64 on the interface

let counter: Counter = Counter::default();
counter.inc();
let _value: u64 = counter.get();

Using AtomicU64 as storage and f64 on the interface

let counter = Counter::<f64, AtomicU64>::default();
counter.inc();
let _value: f64 = counter.get();

Implementations

impl<N, A: Atomic<N>> Counter<N, A>

pub fn inc(&self) -> N

Increase the Counter by 1, returning the previous value.

pub fn inc_by(&self, v: N) -> N

Increase the Counter by v, returning the previous value.

Examples found in repository

src/metrics/exemplar.rs (line 126)

    pub fn inc_by(&self, v: N, label_set: Option<S>) -> N {
        let mut inner = self.inner.write();

        inner.exemplar = label_set.map(|label_set| Exemplar {
            label_set,
            value: v.clone(),
        });

        inner.counter.inc_by(v)
    }

pub fn get(&self) -> N

Get the current value of the Counter.

Examples found in repository

src/metrics/counter.rs (line 182)

    fn encode(&self, mut encoder: MetricEncoder) -> Result<(), std::fmt::Error> {
        encoder.encode_counter::<(), _, u64>(&self.get(), None)
    }

src/metrics/exemplar.rs (line 133)

    pub fn get(&self) -> (N, MappedRwLockReadGuard<Option<Exemplar<S, N>>>) {
        let inner = self.inner.read();
        let value = inner.counter.get();
        let exemplar = RwLockReadGuard::map(inner, |inner| &inner.exemplar);
        (value, exemplar)
    }

pub fn inner(&self) -> &A

Exposes the inner atomic type of the Counter.

This should only be used for advanced use-cases which are not directly supported by the library.

The caller of this function has to uphold the property of an Open Metrics counter namely that the value is monotonically increasing, i.e. either stays the same or increases.

Examples found in repository

src/metrics/exemplar.rs (line 147)

    pub fn inner(&self) -> MappedRwLockReadGuard<A> {
        RwLockReadGuard::map(self.inner.read(), |inner| inner.counter.inner())
    }

Trait Implementations

impl<N, A> Clone for Counter<N, A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug, A: Debug> Debug for Counter<N, A>

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

Formats the value using the given formatter.

impl<N, A: Default> Default for Counter<N, A>

fn default() -> Self

Returns the “default value” for a type.

impl<N, A> EncodeMetric for Counter<N, A>where
    N: EncodeCounterValue,
    A: Atomic<N>,

fn encode(&self, encoder: MetricEncoder<'_, '_>) -> Result<(), Error>

Encode the given instance in the OpenMetrics text encoding.

fn metric_type(&self) -> MetricType

The OpenMetrics metric type of the instance.

impl<N, A> TypedMetric for Counter<N, A>

const TYPE: MetricType = MetricType::Counter

The OpenMetrics metric type.