Struct dipstick::Stream

pub struct Stream<W: Write + Send + Sync + 'static> { /* private fields */ }

Buffered metrics text Input.

Implementations

impl<W: Write + Send + Sync + 'static> Stream<W>

pub fn write_to(write: W) -> Stream<W>

Write metric values to provided Write target.

Examples found in repository

examples/cache.rs (line 9)

fn main() {
    let metrics = Stream::write_to(io::stdout())
        .cached(5)
        .metrics()
        .named("cache");

    loop {
        // report some ad-hoc metric values from our "application" loop
        metrics.counter("blorf").count(1134);
        metrics.marker("burg").mark();

        sleep(Duration::from_millis(500));
    }
}

examples/basics.rs (line 11)

fn main() {
    // for this demo, print metric values to the console
    let app_metrics = Stream::write_to(io::stdout()).metrics();

    // metrics can be predefined by type and name
    let counter = app_metrics.counter("counter_a");
    let level = app_metrics.level("level_a");
    let timer = app_metrics.timer("timer_b");

    // metrics can also be declared and used ad-hoc (use output.cache() if this happens often)
    app_metrics.counter("just_once").count(4);

    // metric names can be prepended with a common prefix
    let prefixed_metrics = app_metrics.named("subsystem");
    let event = prefixed_metrics.marker("event_c");
    let gauge = prefixed_metrics.gauge("gauge_d");

    // each kind of metric has a different method name to prevent errors
    counter.count(11);
    level.adjust(-4);
    level.adjust(5);

    gauge.value(22);
    gauge.value(-24);

    event.mark();

    // time can be measured multiple equivalent ways:
    // in microseconds (used internally)
    timer.interval_us(35573);

    // using the time! macro
    time!(timer, sleep(Duration::from_millis(5)));

    // using a closure
    timer.time(|| sleep(Duration::from_millis(5)));

    // using a "time handle"
    let start_time = timer.start();
    sleep(Duration::from_millis(5));
    timer.stop(start_time);
}

impl Stream<File>

pub fn to_file<P: AsRef<Path>>(file: P) -> Result<Stream<File>>

👎Deprecated since 0.8.0: Use write_to_file()

Write metric values to a file.

pub fn write_to_file<P: AsRef<Path>>(file: P) -> Result<Stream<File>>

Write metric values to a file.

pub fn to_new_file<P: AsRef<Path>>( file: P, clobber: bool, ) -> Result<Stream<File>>

👎Deprecated since 0.8.0: Use write_to_new_file()

Write metrics to a new file.

Creates a new file to dump data into. If clobber is set to true, it allows overwriting existing file, if false, the attempt will result in an error.

pub fn write_to_new_file<P: AsRef<Path>>( file: P, clobber: bool, ) -> Result<Stream<File>>

Write metrics to a new file.

Creates a new file to dump data into. If clobber is set to true, it allows overwriting existing file, if false, the attempt will result in an error.

impl Stream<Stderr>

pub fn to_stderr() -> Stream<Stderr>

👎Deprecated since 0.8.0: Use write_to_stderr()

Write metric values to stderr.

pub fn write_to_stderr() -> Stream<Stderr>

Write metric values to stderr.

Examples found in repository

examples/text_format_label.rs (line 33)

fn main() {
    let counter = Stream::write_to_stderr()
        .formatting(MyFormat)
        .metrics()
        .counter("counter_a");
    AppLabel::set("abc", "xyz");
    loop {
        // report some metric values from our "application" loop
        counter.count(11);
        sleep(Duration::from_millis(500));
    }
}

examples/multi_input.rs (line 15)

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/custom_publish.rs (line 43)

fn main() {
    fn custom_statistics(
        kind: InputKind,
        mut name: MetricName,
        score: ScoreType,
    ) -> Option<(InputKind, MetricName, MetricValue)> {
        match (kind, score) {
            // do not export gauge scores
            (InputKind::Gauge, _) => None,

            // prepend and append to metric name
            (_, ScoreType::Count(count)) => {
                if let Some(last) = name.pop_back() {
                    Some((
                        InputKind::Counter,
                        name.append("customized_add_prefix")
                            .append(format!("{}_and_a_suffix", last)),
                        count,
                    ))
                } else {
                    None
                }
            }

            // scaling the score value and appending unit to name
            (kind, ScoreType::Sum(sum)) => Some((kind, name.append("per_thousand"), sum / 1000)),

            // using the unmodified metric name
            (kind, ScoreType::Mean(avg)) => Some((kind, name, avg.round() as MetricValue)),

            // do not export min and max
            _ => None,
        }
    }

    // send application metrics to aggregator
    AtomicBucket::default_drain(Stream::write_to_stderr());
    AtomicBucket::default_stats(custom_statistics);

    let app_metrics = AtomicBucket::new();

    // schedule aggregated metrics to be printed every 3 seconds
    app_metrics.flush_every(Duration::from_secs(3));

    let counter = app_metrics.counter("counter_a");
    let timer = app_metrics.timer("timer_b");
    let gauge = app_metrics.gauge("gauge_c");
    loop {
        counter.count(11);
        timer.interval_us(654654);
        gauge.value(3534);
    }
}

impl Stream<Stdout>

pub fn to_stdout() -> Stream<Stdout>

👎Deprecated since 0.8.0: Use write_to_stdout()

Write metric values to stdout.

pub fn write_to_stdout() -> Stream<Stdout>

Write metric values to stdout.

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));
    }
}

examples/buffered_flush_on_drop.rs (line 9)

fn main() {
    let input = Stream::write_to_stdout().buffered(Buffering::Unlimited);

    loop {
        println!("\n------- open scope");

        let metrics = input.metrics();

        metrics.marker("marker_a").mark();

        sleep(Duration::from_millis(1000));

        println!("------- close scope: ");
    }
}

examples/bucket_cleanup.rs (line 10)

fn main() {
    let bucket = AtomicBucket::new();
    AtomicBucket::default_drain(Stream::write_to_stdout());

    let persistent_marker = bucket.marker("persistent");

    let mut i = 0;

    loop {
        i += 1;
        let transient_marker = bucket.marker(&format!("marker_{}", i));

        transient_marker.mark();
        persistent_marker.mark();

        bucket.flush().unwrap();

        sleep(Duration::from_secs(1));
    }
}

examples/async_queue.rs (line 9)

fn main() {
    let async_metrics = Stream::write_to_stdout().queued(100).metrics();
    let counter = async_metrics.counter("counter_a");
    for _ in 0..4 {
        let counter = counter.clone();
        thread::spawn(move || {
            loop {
                // report some metric values from our "application" loop
                counter.count(11);
                sleep(Duration::from_millis(50));
            }
        });
    }
    sleep(Duration::from_secs(5000));
}

examples/bench_bucket.rs (line 28)

fn main() {
    let bucket = AtomicBucket::new();
    let event = bucket.marker("a");
    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.stats(stats_all);
    bucket
        .flush_to(&Stream::write_to_stdout().metrics())
        .unwrap();
}

examples/bench_bucket_proxy.rs (line 31)

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();
}

Additional examples can be found in:

• examples/observer.rs
• examples/bucket2stdout.rs
• examples/bucket_summary.rs
• examples/bench_queue.rs
• examples/clopwizard.rs
• examples/multi_input.rs
• examples/proxy.rs
• examples/proxy_multi.rs

Trait Implementations

impl<W: Write + Send + Sync + 'static> Buffered for Stream<W>

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<W: Write + Send + Sync + 'static> CachedInput for Stream<W>

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<W: Write + Send + Sync + 'static> Clone for Stream<W>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<W: Write + Send + Sync + 'static> Formatting for Stream<W>

fn formatting(&self, format: impl LineFormat + 'static) -> Self

Specify formatting of output.

impl<W: Write + Send + Sync + 'static> Input for Stream<W>

type SCOPE = TextScope<W>

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<W: Write + Send + Sync + 'static> QueuedInput for Stream<W>

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

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

impl<W: Write + Send + Sync + 'static> WithAttributes for Stream<W>

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.