Struct dipstick::Graphite

pub struct Graphite { /* private fields */ }

Graphite Input holds a socket to a graphite server. The socket is shared between scopes opened from the Input.

Implementations

impl Graphite

pub fn send_to<A: ToSocketAddrs + Debug + Clone>(address: A) -> Result<Graphite>

Send metrics to a graphite server at the address and port provided.

Examples found in repository

examples/graphite.rs (line 7)

fn main() {
    let metrics = Graphite::send_to("localhost:2003")
        .expect("Connected")
        .named("my_app")
        .metrics();

    loop {
        metrics.counter("counter_a").count(123);
        metrics.timer("timer_a").interval_us(2000000);
        std::thread::sleep(Duration::from_millis(40));
    }
}

examples/multi_input.rs (line 9)

fn main() {
    // will output metrics to graphite and to stdout
    let different_type_metrics = MultiInput::new()
        .add_target(Graphite::send_to("localhost:2003").expect("Connecting"))
        .add_target(Stream::write_to_stdout())
        .metrics();

    // will output metrics twice, once with "both.yeah" prefix and once with "both.ouch" prefix.
    let same_type_metrics = MultiInput::new()
        .add_target(Stream::write_to_stderr().named("yeah"))
        .add_target(Stream::write_to_stderr().named("ouch"))
        .named("both")
        .metrics();

    loop {
        different_type_metrics.counter("counter_a").count(123);
        same_type_metrics.timer("timer_a").interval_us(2000000);
        std::thread::sleep(Duration::from_millis(400));
    }
}

examples/bucket2graphite.rs (line 14)

fn main() {
    // adding a name to the stats
    let bucket = AtomicBucket::new().named("test");

    // adding two names to Graphite output
    // metrics will be prefixed with "machine1.application.test"
    bucket.drain(
        Graphite::send_to("localhost:2003")
            .expect("Socket")
            .named("machine1")
            .add_name("application"),
    );

    bucket.flush_every(Duration::from_secs(3));

    let counter = bucket.counter("counter_a");
    let timer = bucket.timer("timer_a");
    let gauge = bucket.gauge("gauge_a");
    let marker = bucket.marker("marker_a");

    loop {
        // add counts forever, non-stop
        counter.count(11);
        counter.count(12);
        counter.count(13);

        timer.interval_us(11_000_000);
        timer.interval_us(12_000_000);
        timer.interval_us(13_000_000);

        gauge.value(11);
        gauge.value(12);
        gauge.value(13);

        marker.mark();
    }
}

Trait Implementations

impl Buffered for Graphite

fn buffered(&self, buffering: Buffering) -> Self

Return a clone with the specified buffering set.

fn get_buffering(&self) -> Buffering

Return the current buffering strategy.

fn is_buffered(&self) -> bool

Returns false if the current buffering strategy is Buffering::Unbuffered. Returns true otherwise.

impl CachedInput for Graphite

fn cached(self, max_size: usize) -> InputCache

Wrap an input with a metric definition cache. This can provide performance benefits for metrics that are dynamically defined at runtime on each access. Caching is useless if all metrics are statically declared or instantiated programmatically in advance and referenced by a long living variable.

impl Clone for Graphite

fn clone(&self) -> Graphite

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Graphite

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

Formats the value using the given formatter.

impl Input for Graphite

type SCOPE = GraphiteScope

The type of Scope returned byt this input.

fn metrics(&self) -> Self::SCOPE

Open a new scope from this input.

fn input(&self) -> Self::SCOPE

👎Deprecated since 0.7.2: Use metrics()

Open a new scope from this input.

fn new_scope(&self) -> Self::SCOPE

👎Deprecated since 0.8.0: Use metrics()

Open a new scope from this input.

impl QueuedInput for Graphite

fn queued(self, max_size: usize) -> InputQueue

Wrap this output with an asynchronous dispatch queue of specified length.

impl WithAttributes for Graphite

fn get_attributes(&self) -> &Attributes

Return attributes of component.

fn mut_attributes(&mut self) -> &mut Attributes

Return attributes of component for mutation.

fn with_attributes<F: Fn(&mut Attributes)>(&self, edit: F) -> Self

Clone the component and mutate its attributes at once.