Struct metrix::cockpit::Cockpit

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

A cockpit groups panels.

Use a cockpit to group panels that are somehow related. Since the Cockpit is generic over its label you can use an enum as a label for grouping panels easily.

Methods

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

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

Creates a new instance.

Even though the name is optional it is suggested to use a name for a cockpit since in most cases a Cockpit is a meaningful grouping for panels and instruments.

pub fn without_name() -> Cockpit<L>

Creates a new Cockpit without a name.

This will have the effect that there will be no grouping in the snapshot around the contained components.

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

Returns the name of this cockpit.

If there is a name set, this will group the inner components in the snapshot.

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

Sets a name for this Cockpit. This will also enable grouping.

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

Sets the title which will be displayed if a descriptive snapshot is requested.

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

Sets the description which will be displayed if a descriptive snapshot is requested.

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

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

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

Add a Panel to this cockpit.

A Panel will receive only those Observations where labels match.

There can be multiple Panels for the same label.

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

Add a Panel to this cockpit.

A Panel will receive only those Observations where labels match.

There can be multiple Panels for the same label.

pub fn get_panels(&self) -> Vec<&Panel<L>>

Returns the Panels

pub fn get_panels_mut(&mut self) -> Vec<&mut Panel<L>>

Returns the Panels mutable

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

Add a handler. This can be custom logic for metrics.

A handler will be passed all Observations unlike a Panel which will only receive Observations where the label matches.

pub fn handlers(&self) -> Vec<&dyn HandlesObservations<Label = L>>

Returns all the handlers.

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

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

Adds a snapshooter.

A snapshooter will only be invoked when a Snapshot is requested. It will never receive an Observation.

pub fn snapshooters(&self) -> Vec<&dyn PutsSnapshot>

Returns all snapshooters.

Trait Implementations

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

type Label = L

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

impl<L> Descriptive for Cockpit<L>

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

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

impl<L> PutsSnapshot for Cockpit<L> where
    L: Clone + 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.

impl<L> Default for Cockpit<L> where
    L: Clone + Eq + Send + 'static, 

fn default() -> Cockpit<L>

Returns the "default value" for a type.