rs-zero 0.1.1

Rust-first microservice framework inspired by go-zero engineering practices
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use std::{
    collections::BTreeMap,
    fmt::Write,
    sync::{Arc, Mutex},
    time::Duration,
};

/// Low-cardinality labels recorded for each HTTP request.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct HttpMetricLabels {
    /// HTTP method.
    pub method: String,
    /// Route pattern or explicit route name. Raw request paths should not be used.
    pub route: String,
    /// HTTP status code.
    pub status: u16,
}

impl HttpMetricLabels {
    /// Creates a label set for one HTTP request.
    pub fn new(method: impl Into<String>, route: impl Into<String>, status: u16) -> Self {
        Self {
            method: method.into(),
            route: route.into(),
            status,
        }
    }
}

#[derive(Debug, Clone, Default)]
struct HttpMetricValue {
    count: u64,
    duration_seconds_sum: f64,
}

/// In-process metrics registry with Prometheus text export.
#[derive(Debug, Clone, Default)]
pub struct MetricsRegistry {
    http_requests: Arc<Mutex<BTreeMap<HttpMetricLabels, HttpMetricValue>>>,
}

impl MetricsRegistry {
    /// Creates an empty registry.
    pub fn new() -> Self {
        Self::default()
    }

    /// Records an HTTP request duration.
    pub fn record_http_request(&self, labels: HttpMetricLabels, duration: Duration) {
        let mut metrics = self.http_requests.lock().expect("metrics mutex");
        let entry = metrics.entry(labels).or_default();
        entry.count += 1;
        entry.duration_seconds_sum += duration.as_secs_f64();
    }

    /// Renders all metrics in Prometheus text exposition format.
    pub fn render_prometheus(&self) -> String {
        let metrics = self.http_requests.lock().expect("metrics mutex");
        let mut output = String::new();
        output.push_str("# HELP rs_zero_http_requests_total Total number of HTTP requests.\n");
        output.push_str("# TYPE rs_zero_http_requests_total counter\n");
        for (labels, value) in metrics.iter() {
            let _ = writeln!(
                output,
                "rs_zero_http_requests_total{{method=\"{}\",route=\"{}\",status=\"{}\"}} {}",
                escape_label(&labels.method),
                escape_label(&labels.route),
                labels.status,
                value.count
            );
        }

        output.push_str(
            "# HELP rs_zero_http_request_duration_seconds_sum Sum of HTTP request durations.\n",
        );
        output.push_str("# TYPE rs_zero_http_request_duration_seconds_sum counter\n");
        for (labels, value) in metrics.iter() {
            let _ = writeln!(
                output,
                "rs_zero_http_request_duration_seconds_sum{{method=\"{}\",route=\"{}\",status=\"{}\"}} {:.6}",
                escape_label(&labels.method),
                escape_label(&labels.route),
                labels.status,
                value.duration_seconds_sum
            );
        }
        output
    }
}

fn escape_label(value: &str) -> String {
    value.replace('\\', "\\\\").replace('"', "\\\"")
}

#[cfg(test)]
mod tests {
    use std::time::Duration;

    use super::{HttpMetricLabels, MetricsRegistry};

    #[test]
    fn metrics_render_prometheus_text() {
        let registry = MetricsRegistry::new();
        registry.record_http_request(
            HttpMetricLabels::new("GET", "/users/:id", 200),
            Duration::from_millis(20),
        );
        let text = registry.render_prometheus();
        assert!(text.contains("rs_zero_http_requests_total"));
        assert!(text.contains("route=\"/users/:id\""));
        assert!(!text.contains("/users/42"));
    }
}