benchmark 0.8.0

Nanosecond-precision benchmarking for dev, testing, and production. Zero-overhead core timing when disabled; optional std-powered collectors and zero-dependency metrics (Watch/Timer) for real service observability.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

// Run with: cargo run --example prometheus_textfile --features "std metrics"
// This writes a Prometheus text exposition file to target/metrics.prom by default.

#[cfg(all(feature = "std", feature = "metrics"))]
use std::fs;
#[cfg(all(feature = "std", feature = "metrics"))]
use std::io::Write;
#[cfg(all(feature = "std", feature = "metrics"))]
use std::path::PathBuf;
#[cfg(all(feature = "std", feature = "metrics"))]
use std::time::Duration as StdDuration;

#[cfg(all(feature = "std", feature = "metrics"))]
use benchmark::{stopwatch, Watch};

#[cfg(all(feature = "std", feature = "metrics"))]
fn prometheus_export(w: &Watch) -> String {
    let mut out = String::new();
    for (name, s) in w.snapshot() {
        // Convert percentiles and aggregates into gauges
        out.push_str(&format!(
            "benchmark_latency_p50{{name=\"{}\"}} {}\n",
            name, s.p50
        ));
        out.push_str(&format!(
            "benchmark_latency_p90{{name=\"{}\"}} {}\n",
            name, s.p90
        ));
        out.push_str(&format!(
            "benchmark_latency_p99{{name=\"{}\"}} {}\n",
            name, s.p99
        ));
        out.push_str(&format!(
            "benchmark_latency_max{{name=\"{}\"}} {}\n",
            name, s.max
        ));
        out.push_str(&format!(
            "benchmark_latency_mean{{name=\"{}\"}} {:.1}\n",
            name, s.mean
        ));
        out.push_str(&format!(
            "benchmark_latency_count{{name=\"{}\"}} {}\n",
            name, s.count
        ));
    }
    out
}

#[cfg(all(feature = "std", feature = "metrics"))]
fn main() -> std::io::Result<()> {
    // Build a small set of metrics
    let watch = Watch::new();

    stopwatch!(watch, "io.read", {
        std::thread::sleep(StdDuration::from_millis(2));
    });
    stopwatch!(watch, "io.write", {
        std::thread::sleep(StdDuration::from_millis(3));
    });

    // Export to Prometheus text format
    let text = prometheus_export(&watch);

    // Determine output path
    let mut path = PathBuf::from("target/metrics.prom");
    if let Some(arg1) = std::env::args().nth(1) {
        path = PathBuf::from(arg1);
    }

    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent)?;
    }
    let mut f = fs::File::create(&path)?;
    f.write_all(text.as_bytes())?;

    eprintln!("Wrote {} bytes to {}", text.len(), path.display());
    Ok(())
}

#[cfg(not(all(feature = "std", feature = "metrics")))]
fn main() {
    eprintln!(
        "This example requires features: std + metrics.\nRun: cargo run --example prometheus_textfile --features \"std metrics\""
    );
}