Struct Counter 

pub struct Counter { /* private fields */ }

A simple ever increasing counter

Reacts to the following Observations:

• Observation::Observed(Update::Observations)
• Obervation::ObservedOne(Update::Observation)
• Obervation::ObservedOneValue(Update::ObservationWithValue)

Example

use std::time::Instant;
use metrix::instruments::*;

let mut counter = Counter::new_with_defaults("example");
let update = Update::Observation(Instant::now());
counter.update(&update);

assert_eq!(1, counter.get());

Implementations

impl Counter

pub fn new<T: Into<String>>(name: T) -> Counter

pub fn new_with_defaults<T: Into<String>>(name: T) -> Counter

Examples found in repository

examples/demo_run.rs (line 50)

fn create_foo_metrics() -> (TelemetryTransmitter<FooLabel>, ProcessorMount) {
    let mut foo_a_panel = Panel::named(FooLabel::A, "foo_a_panel");
    foo_a_panel.add_counter(Counter::new_with_defaults("foo_a_counter"));
    let mut gauge = Gauge::new_with_defaults("foo_a_gauge");
    gauge.set_title("title");
    gauge.set_description("description");
    foo_a_panel.add_gauge(gauge);
    foo_a_panel.add_meter(Meter::new_with_defaults("foo_a_meter"));
    foo_a_panel.add_histogram(Histogram::new_with_defaults("foo_a_histogram"));
    foo_a_panel.set_title("foo_1_panel_title");
    foo_a_panel.set_description("foo_a_panel_description");

    let mut foo_b_panel = Panel::new(FooLabel::B);
    foo_b_panel.add_counter(Counter::new_with_defaults("foo_b_counter"));
    let mut gauge = Gauge::new_with_defaults("foo_b_gauge").tracking(15);
    gauge.set_title("title");
    gauge.set_description("description");
    foo_b_panel.add_gauge(gauge);
    foo_b_panel.add_meter(Meter::new_with_defaults("foo_b_meter"));
    foo_b_panel.add_histogram(Histogram::new_with_defaults("foo_b_histogram"));
    foo_b_panel.set_title("foo_b_panel_title");
    foo_b_panel.set_description("foo_b_panel_description");

    let polled_counter = PolledCounter::new();
    let mut polled_instrument =
        PollingInstrument::new_with_defaults("polled_instrument_1", polled_counter);
    polled_instrument.set_title("The polled counter 1");
    polled_instrument.set_description("A counter that is increased when a snapshot is polled");
    foo_b_panel.add_snapshooter(polled_instrument);

    let staircase_timer = StaircaseTimer::new("staircase");
    foo_b_panel.add_instrument(staircase_timer);

    let mut cockpit = Cockpit::new("foo_cockpit");
    cockpit.add_panel(foo_a_panel);
    cockpit.add_panel(foo_b_panel);
    cockpit.set_title("foo_cockpit_title");
    cockpit.set_description("foo_cockpit_description");

    let (tx, mut processor) = TelemetryProcessor::new_pair("processor_foo");

    processor.add_cockpit(cockpit);

    let mut group_processor = ProcessorMount::default();
    group_processor.add_processor(processor);

    (tx, group_processor)
}

fn create_bar_metrics() -> (TelemetryTransmitter<BarLabel>, ProcessorMount) {
    let mut bar_a_panel = Panel::named(BarLabel::A, "bar_a_panel")
        .counter(Counter::new_with_defaults("bar_a_counter"));
    bar_a_panel.add_gauge(Gauge::new_with_defaults("bar_a_gauge"));
    bar_a_panel.add_meter(Meter::new_with_defaults("bar_a_meter"));
    bar_a_panel.add_histogram(Histogram::new_with_defaults("bar_a_histogram"));

    let mut bar_a_cockpit = Cockpit::without_name();
    bar_a_cockpit.add_panel(bar_a_panel);

    let mut bar_b_panel = Panel::new(BarLabel::B);
    bar_b_panel.add_counter(Counter::new_with_defaults("bar_b_counter"));
    bar_b_panel.add_gauge(Gauge::new_with_defaults("bar_b_gauge"));
    bar_b_panel.add_meter(Meter::new_with_defaults("bar_b_meter"));
    bar_b_panel.add_histogram(Histogram::new_with_defaults("bar_b_histogram"));

    let mut bar_b_cockpit = Cockpit::new("bar_b_cockpit");
    bar_b_cockpit.add_panel(bar_b_panel);

    let mut bar_c_panel = Panel::named(BarLabel::C, "bar_c_panel");
    bar_c_panel.add_counter(Counter::new_with_defaults("bar_c_counter"));
    bar_c_panel.add_gauge(Gauge::new_with_defaults("bar_c_gauge"));
    bar_c_panel.add_meter(Meter::new_with_defaults("bar_c_meter"));
    bar_c_panel.add_histogram(Histogram::new_with_defaults("bar_c_histogram"));

    let mut bar_c_cockpit = Cockpit::new("bar_c_cockpit");
    bar_c_cockpit.add_panel(bar_c_panel);

    let (tx, mut processor) = TelemetryProcessor::new_pair_without_name();

    processor.add_cockpit(bar_a_cockpit);
    processor.add_cockpit(bar_b_cockpit);
    processor.add_cockpit(bar_c_cockpit);

    let mut group_processor1 = ProcessorMount::default();
    group_processor1.add_processor(processor);

    let mut group_processor2 = ProcessorMount::default();
    group_processor2.add_processor(group_processor1);
    group_processor2.set_name("group_processor_2");

    let polled_counter = PolledCounter::new();
    let mut polled_instrument =
        PollingInstrument::new_with_defaults("polled_instrument_2", polled_counter);
    polled_instrument.set_title("The polled counter 2");
    polled_instrument.set_description("A counter that is increased when a snapshot is polled");

    group_processor2.add_snapshooter(polled_instrument);

    (tx, group_processor2)
}

pub fn get_name(&self) -> &str

pub fn set_name<T: Into<String>>(&mut self, name: T)

pub fn name<T: Into<String>>(self, name: T) -> Self

pub fn set_title<T: Into<String>>(&mut self, title: T)

pub fn title<T: Into<String>>(self, title: T) -> Self

pub fn set_description<T: Into<String>>(&mut self, description: T)

pub fn description<T: Into<String>>(self, description: T) -> Self

pub fn inc(&mut self)

Increase the stored value by one.

pub fn inc_by(&mut self, n: u64)

Increase the stored value by n

pub fn get(&self) -> u64

Get the current value

pub fn accept<L: Eq + Send + 'static, F: Into<LabelFilter<L>>>( self, accept: F, ) -> InstrumentAdapter<L, Self>

pub fn for_label<L: Eq + Send + 'static>( self, label: L, ) -> InstrumentAdapter<L, Self>

Creates an InstrumentAdapter that makes this instrument react on observations on the given label.

pub fn for_labels<L: Eq + Send + 'static>( self, labels: Vec<L>, ) -> InstrumentAdapter<L, Self>

Creates an InstrumentAdapter that makes this instrument react on observations with the given labels.

If labels is empty the instrument will not react to any observations

pub fn for_all_labels<L: Eq + Send + 'static>( self, ) -> InstrumentAdapter<L, Self>

Creates an InstrumentAdapter that makes this instrument react on all observations.

pub fn for_labels_by_predicate<L, P>( self, label_predicate: P, ) -> InstrumentAdapter<L, Self>

where L: Eq + Send + 'static, P: Fn(&L) -> bool + Send + 'static,

Creates an InstrumentAdapter that makes this instrument react on observations with labels specified by the predicate.

pub fn adapter<L: Eq + Send + 'static>(self) -> InstrumentAdapter<L, Self>

Creates an InstrumentAdapter that makes this instrument to no observations.

Trait Implementations

impl Descriptive for Counter

fn title(&self) -> Option<&str>

fn description(&self) -> Option<&str>

impl PutsSnapshot for Counter

fn put_snapshot(&self, into: &mut Snapshot, descriptive: bool)

Puts the current snapshot values into the given Snapshot thereby following the guidelines of PutsSnapshot.

impl Updates for Counter

fn update(&mut self, with: &Update) -> usize

Update the internal state according to the given Update.

impl Instrument for Counter