fast-telemetry 0.3.0

High-performance, cache-friendly telemetry primitives and export formats for Rust
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

//! Basic usage of fast-telemetry counters, gauges, and histograms.
//!
//! Run with: cargo run --example basic

use std::time::Duration;

use fast_telemetry::{Counter, ExportMetrics, Gauge, Histogram, SampledTimer};

#[derive(ExportMetrics)]
#[metric_prefix = "myapp"]
struct AppMetrics {
    #[help = "Total requests processed"]
    requests: Counter,

    #[help = "Request latency in microseconds"]
    latency: Histogram,

    #[help = "Hot path latency"]
    hot_path_latency: SampledTimer,

    #[help = "Current queue depth"]
    queue_depth: Gauge,
}

impl AppMetrics {
    fn new() -> Self {
        Self {
            // Use number of CPUs for shard count in production
            requests: Counter::new(4),
            latency: Histogram::with_latency_buckets(4),
            hot_path_latency: SampledTimer::with_latency_buckets(4, 64),
            queue_depth: Gauge::new(),
        }
    }
}

fn main() {
    let metrics = AppMetrics::new();

    // Simulate some work
    for i in 0..100 {
        metrics.requests.inc();
        metrics.latency.record(50 + (i % 200)); // 50-250µs
        metrics
            .hot_path_latency
            .record_elapsed(Duration::from_nanos(80_000 + (i % 200) * 1_000));
    }
    metrics.queue_depth.set(42);

    // Export to Prometheus format
    println!("=== Prometheus Format ===\n");
    let mut prom = String::new();
    metrics.export_prometheus(&mut prom);
    println!("{}", prom);

    // Export to DogStatsD format
    println!("=== DogStatsD Format ===\n");
    let mut statsd = String::new();
    metrics.export_dogstatsd(&mut statsd, &[("env", "dev")]);
    println!("{}", statsd);
}