Struct metrix::instruments::Panel

pub struct Panel<L> { /* fields omitted */ }

The panel shows recorded observations with the same label in different representations.

Let's say you want to monitor the successful requests of a specific endpoint of your REST API. You would then create a panel for this and might want to add a counter and a meter and a histogram to track latencies.

Example

use std::time::Instant;
use metrix::instruments::*;
use metrix::{HandlesObservations, Observation};

#[derive(Clone, PartialEq, Eq)]
struct SuccessfulRequests;

let counter = Counter::new_with_defaults("count");
let gauge = Gauge::new_with_defaults("last_latency");
let meter = Meter::new_with_defaults("per_second");
let histogram = Histogram::new_with_defaults("latencies");

assert_eq!(0, counter.get());
assert_eq!(None, gauge.get());

let mut panel = Panel::named(SuccessfulRequests, "successful_requests");
panel.set_counter(counter);
panel.set_gauge(gauge);
panel.set_meter(meter);
panel.set_histogram(histogram);

let observation = Observation::ObservedOneValue {
       label: SuccessfulRequests,
       value: 12.into(),
       timestamp: Instant::now(),
};
panel.handle_observation(&observation);

assert_eq!(Some(1), panel.get_counter().map(|c| c.get()));
assert_eq!(Some(12), panel.get_gauge().and_then(|g| g.get()));

Methods

impl<L> Panel<L> where
    L: Eq + Send + 'static, 

pub fn new(label: L) -> Panel<L>

Create a new Panel without a name which dispatches observations with the given label

pub fn with_name<T: Into<String>>(label: L, name: T) -> Panel<L>

Deprecated since 0.9.24:

use 'named'

Create a new Panel with the given name which dispatches observations with the given label

pub fn named<T: Into<String>>(label: L, name: T) -> Panel<L>

Create a new Panel with the given name which dispatches observations with the given label

pub fn accept(labels: Vec<L>) -> Self

Create a new Panel without a name which dispatches observations with the given labels

pub fn accept_named<T: Into<String>>(labels: Vec<L>, name: T) -> Self

Create a new Panel with the given name which dispatches observations with the given labels

pub fn accept_all_named<T: Into<String>>(name: T) -> Panel<L>

Create a new Panel with the given name which dispatches all observations

pub fn accept_all() -> Panel<L>

Create a new Panel without a name which dispatches all observations

pub fn set_counter<I: Into<InstrumentAdapter<L, Counter>>>(
    &mut self,
    counter: I
)

pub fn counter<I: Into<InstrumentAdapter<L, Counter>>>(self, counter: I) -> Self

pub fn get_counter(&self) -> Option<&Counter>

pub fn set_gauge<I: Into<GaugeAdapter<L>>>(&mut self, gauge: I)

pub fn gauge<I: Into<GaugeAdapter<L>>>(self, gauge: I) -> Self

pub fn get_gauge(&self) -> Option<&Gauge>

pub fn set_meter<I: Into<InstrumentAdapter<L, Meter>>>(&mut self, meter: I)

pub fn meter<I: Into<InstrumentAdapter<L, Meter>>>(self, meter: I) -> Self

pub fn get_meter(&self) -> Option<&Meter>

pub fn set_histogram<I: Into<InstrumentAdapter<L, Histogram>>>(
    &mut self,
    histogram: I
)

pub fn histogram<I: Into<InstrumentAdapter<L, Histogram>>>(
    self,
    histogram: I
) -> Self

pub fn get_histogram(&self) -> Option<&Histogram>

pub fn add_snapshooter<T: PutsSnapshot>(&mut self, snapshooter: T)

pub fn snapshooter<T: PutsSnapshot>(self, snapshooter: T) -> Self

pub fn add_instrument<I: Instrument>(&mut self, instrument: I)

pub fn instrument<T: Instrument>(self, instrument: T) -> Self

pub fn add_panel(&mut self, panel: Panel<L>)

pub fn panel(self, panel: Panel<L>) -> Self

pub fn add_handler<H: HandlesObservations<Label = L>>(&mut self, handler: H)

pub fn handler<H: HandlesObservations<Label = L>>(self, handler: H) -> Self

pub fn name(&self) -> Option<&str>

Gets the name of this Panel

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

Set the name if this Panel.

The name is a path segment within a Snapshot

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

Sets the title of this Panel.

A title can be part of a descriptive Snapshot

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

Sets the description of this Panel.

A description can be part of a descriptive Snapshot

pub fn set_inactivity_limit(&mut self, limit: Duration)

Sets the maximum amount of time this panel may be inactive until no more snapshots are taken

Default is no inactivity tracking.

pub fn accepts_label(&self, label: &L) -> bool

Trait Implementations

impl<L> HandlesObservations for Panel<L> where
    L: Eq + Send + 'static, 

type Label = L

fn handle_observation(
    &mut self,
    observation: &Observation<Self::Label>
) -> usize

impl<L> Descriptive for Panel<L>

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

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

impl<L> PutsSnapshot for Panel<L> where
    L: Eq + Send + 'static, 

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

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