Struct dipstick::Proxy

pub struct Proxy { /* private fields */ }

A dynamic proxy for app and lib metrics. Decouples metrics definition from backend configuration. Allows defining metrics before a concrete type is configured. Allows replacing metrics backend on the fly at runtime.

Implementations

impl Proxy

pub fn new() -> Self

Create a new “private” metric proxy root. This is usually not what you want. Since this proxy will not be part of the standard proxy tree, it will need to be configured independently and since downstream code may not know about its existence this may never happen and metrics will not be proxyed anywhere. If you want to use the standard proxy tree, use #metric_proxy() instead.

pub fn set_target<T: InputScope + Send + Sync + 'static>(&self, target: T)

👎Deprecated since 0.7.2: Use target()

Replace target for this proxy and its children.

pub fn target<T: InputScope + Send + Sync + 'static>(&self, target: T)

Replace target for this proxy and its children.

Examples found in repository

examples/bench_bucket_proxy.rs (line 15)

fn main() {
    let event = Proxy::default().marker("a");

    let bucket = AtomicBucket::new();

    Proxy::default().target(bucket.clone());

    let args = &mut args();
    args.next();
    let tc: u8 = u8::from_str(&args.next().unwrap()).unwrap();
    for _ in 0..tc {
        let event = event.clone();
        thread::spawn(move || {
            loop {
                // report some metric values from our "application" loop
                event.mark();
            }
        });
    }
    sleep(Duration::from_secs(5));
    bucket
        .flush_to(&Stream::write_to_stdout().metrics())
        .unwrap();
}

examples/clopwizard.rs (line 31)

fn main() {
    let one_minute = AtomicBucket::new();
    one_minute.flush_every(Duration::from_secs(60));

    let five_minutes = AtomicBucket::new();
    five_minutes.flush_every(Duration::from_secs(300));

    let fifteen_minutes = AtomicBucket::new();
    fifteen_minutes.flush_every(Duration::from_secs(900));

    let all_buckets = MultiInputScope::new()
        .add_target(one_minute)
        .add_target(five_minutes)
        .add_target(fifteen_minutes)
        .named("machine_name");

    // send application metrics to aggregator
    Proxy::default().target(all_buckets);
    AtomicBucket::default_drain(Stream::write_to_stdout());
    AtomicBucket::default_stats(stats_all);

    loop {
        COUNTER.count(17);
        sleep(Duration::from_secs(3));
    }
}

examples/proxy.rs (line 17)

fn main() {
    let root_proxy = Proxy::default();
    let sub = root_proxy.named("sub");

    let count1 = root_proxy.counter("counter_a");

    let count2 = sub.counter("counter_b");

    loop {
        let stdout = Stream::write_to_stdout().metrics();
        root_proxy.target(stdout.clone());
        count1.count(1);
        count2.count(2);

        // route every metric from the root to stdout with prefix "root"
        root_proxy.target(stdout.named("root"));
        count1.count(3);
        count2.count(4);

        // route metrics from "sub" to stdout with prefix "mutant"
        sub.target(stdout.named("mutant"));
        count1.count(5);
        count2.count(6);

        // clear root metrics route, "sub" still appears
        root_proxy.unset_target();
        count1.count(7);
        count2.count(8);

        // now no metrics appear
        sub.unset_target();
        count1.count(9);
        count2.count(10);

        // go back to initial single un-prefixed route
        root_proxy.target(stdout.clone());
        count1.count(11);
        count2.count(12);

        sleep(Duration::from_secs(1));

        println!()
    }
}

examples/proxy_multi.rs (line 43)

fn main() {
    // Placeholder to collect output targets
    // This will prefix all metrics with "my_stats"
    // before flushing them.
    let mut targets = MultiInput::new().named("my_stats");

    // Skip the metrics here... we just use this for the output
    // Follow the same pattern for Statsd, Graphite, etc.
    let prometheus = Prometheus::push_to("http://localhost:9091/metrics/job/dipstick_example")
        .expect("Prometheus Socket");
    targets = targets.add_target(prometheus);

    // Add stdout
    targets = targets.add_target(Stream::write_to_stdout());

    // Create the stats and drain targets
    let bucket = AtomicBucket::new();
    bucket.drain(targets);
    // Crucial, set the flush interval, otherwise risk hammering targets
    bucket.flush_every(Duration::from_secs(3));

    // Now wire up the proxy target with the stats and you're all set
    let proxy = Proxy::default();
    proxy.target(bucket.clone());

    // Example using the macro! Proxy sugar
    PROXY.target(bucket.named("global"));

    loop {
        // Using the default proxy
        proxy.counter("beans").count(100);
        proxy.timer("braincells").interval_us(420);
        // global example
        PROXY.counter("my_proxy_counter").count(123);
        PROXY.timer("my_proxy_timer").interval_us(2000000);
        std::thread::sleep(Duration::from_millis(100));
    }
}

pub fn unset_target(&self)

Replace target for this proxy and its children.

Examples found in repository

examples/proxy.rs (line 32)

fn main() {
    let root_proxy = Proxy::default();
    let sub = root_proxy.named("sub");

    let count1 = root_proxy.counter("counter_a");

    let count2 = sub.counter("counter_b");

    loop {
        let stdout = Stream::write_to_stdout().metrics();
        root_proxy.target(stdout.clone());
        count1.count(1);
        count2.count(2);

        // route every metric from the root to stdout with prefix "root"
        root_proxy.target(stdout.named("root"));
        count1.count(3);
        count2.count(4);

        // route metrics from "sub" to stdout with prefix "mutant"
        sub.target(stdout.named("mutant"));
        count1.count(5);
        count2.count(6);

        // clear root metrics route, "sub" still appears
        root_proxy.unset_target();
        count1.count(7);
        count2.count(8);

        // now no metrics appear
        sub.unset_target();
        count1.count(9);
        count2.count(10);

        // go back to initial single un-prefixed route
        root_proxy.target(stdout.clone());
        count1.count(11);
        count2.count(12);

        sleep(Duration::from_secs(1));

        println!()
    }
}

pub fn set_default_target<T: InputScope + Send + Sync + 'static>(target: T)

👎Deprecated since 0.7.2: Use default_target()

Install a new default target for all proxies.

pub fn default_target<T: InputScope + Send + Sync + 'static>(target: T)

Install a new default target for all proxies.

Examples found in repository

examples/macro_proxy.rs (line 36)

fn main() {
    dipstick::Proxy::default_target(Stream::write_to_stdout().metrics());

    loop {
        ROOT_COUNTER.count(123);
        ANOTHER_COUNTER.count(456);
        ROOT_TIMER.interval_us(2000000);
        ROOT_GAUGE.value(34534);
        std::thread::sleep(Duration::from_millis(40));
    }
}

pub fn unset_default_target(&self)

Revert to initial state any installed default target for all proxies.

Trait Implementations

impl Clone for Proxy

fn clone(&self) -> Proxy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Proxy

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

Formats the value using the given formatter.

impl Default for Proxy

fn default() -> Self

Return the default root metric proxy.

impl Flush for Proxy

fn flush(&self) -> Result<()>

Flush does nothing by default.

impl<S: AsRef<str>> From<S> for Proxy

fn from(name: S) -> Proxy

Converts to this type from the input type.

impl InputScope for Proxy

fn new_metric(&self, name: MetricName, kind: InputKind) -> InputMetric

Lookup or create a proxy stub for the requested metric.

fn counter(&self, name: &str) -> Counter

Define a Counter.

fn marker(&self, name: &str) -> Marker

Define a Marker.

fn timer(&self, name: &str) -> Timer

Define a Timer.

fn gauge(&self, name: &str) -> Gauge

Define a Gauge.

fn level(&self, name: &str) -> Level

Define a Level.

impl WithAttributes for Proxy

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.