hyperi-rustlib 2.5.1

Opinionated Rust framework for high-throughput data pipelines at PB scale. Auto-wiring config, logging, metrics, tracing, health, and graceful shutdown — built from many years of production infrastructure experience.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

// SPDX-License-Identifier: FSL-1.1-ALv2
// Copyright (c) 2026 HYPERI PTY LIMITED

//! Enrichment cache metrics (GeoIP, reputation, lookup tables).

use super::super::MetricsManager;
use super::super::manifest::{MetricDescriptor, MetricType};

/// Enrichment cache metrics.
///
/// Tracks cache hit/miss rates, cache size, and lookup latency.
/// The `type` label distinguishes enrichment sources (e.g., `geoip`, `reputation`).
#[derive(Clone)]
pub struct EnrichmentMetrics {
    namespace: String,
}

impl EnrichmentMetrics {
    #[must_use]
    pub fn new(manager: &MetricsManager) -> Self {
        let ns = manager.namespace();

        // enrichment_cache_hits_total — label-based
        let hits_key = if ns.is_empty() {
            "enrichment_cache_hits_total".to_string()
        } else {
            format!("{ns}_enrichment_cache_hits_total")
        };
        metrics::describe_counter!(hits_key.clone(), "Enrichment cache hits");
        manager.registry().push(MetricDescriptor {
            name: hits_key,
            metric_type: MetricType::Counter,
            description: "Enrichment cache hits".into(),
            unit: String::new(),
            labels: vec!["type".into()],
            group: "enrichment".into(),
            buckets: None,
            use_cases: vec![],
            dashboard_hint: None,
        });

        // enrichment_cache_misses_total — label-based
        let misses_key = if ns.is_empty() {
            "enrichment_cache_misses_total".to_string()
        } else {
            format!("{ns}_enrichment_cache_misses_total")
        };
        metrics::describe_counter!(misses_key.clone(), "Enrichment cache misses");
        manager.registry().push(MetricDescriptor {
            name: misses_key,
            metric_type: MetricType::Counter,
            description: "Enrichment cache misses".into(),
            unit: String::new(),
            labels: vec!["type".into()],
            group: "enrichment".into(),
            buckets: None,
            use_cases: vec![],
            dashboard_hint: None,
        });

        // enrichment_cache_size — label-based
        let size_key = if ns.is_empty() {
            "enrichment_cache_size".to_string()
        } else {
            format!("{ns}_enrichment_cache_size")
        };
        metrics::describe_gauge!(size_key.clone(), "Current enrichment cache entries");
        manager.registry().push(MetricDescriptor {
            name: size_key,
            metric_type: MetricType::Gauge,
            description: "Current enrichment cache entries".into(),
            unit: String::new(),
            labels: vec!["type".into()],
            group: "enrichment".into(),
            buckets: None,
            use_cases: vec![],
            dashboard_hint: None,
        });

        // enrichment_duration_seconds — label-based
        let dur_key = if ns.is_empty() {
            "enrichment_duration_seconds".to_string()
        } else {
            format!("{ns}_enrichment_duration_seconds")
        };
        metrics::describe_histogram!(
            dur_key.clone(),
            metrics::Unit::Seconds,
            "Enrichment lookup latency"
        );
        manager.registry().push(MetricDescriptor {
            name: dur_key,
            metric_type: MetricType::Histogram,
            description: "Enrichment lookup latency".into(),
            unit: "seconds".into(),
            labels: vec!["type".into()],
            group: "enrichment".into(),
            buckets: None,
            use_cases: vec![],
            dashboard_hint: None,
        });

        Self {
            namespace: ns.to_string(),
        }
    }

    #[inline]
    pub fn record_hit(&self, enrichment_type: &str) {
        let key = if self.namespace.is_empty() {
            "enrichment_cache_hits_total".to_string()
        } else {
            format!("{}_enrichment_cache_hits_total", self.namespace)
        };
        metrics::counter!(key, "type" => enrichment_type.to_string()).increment(1);
    }

    #[inline]
    pub fn record_miss(&self, enrichment_type: &str) {
        let key = if self.namespace.is_empty() {
            "enrichment_cache_misses_total".to_string()
        } else {
            format!("{}_enrichment_cache_misses_total", self.namespace)
        };
        metrics::counter!(key, "type" => enrichment_type.to_string()).increment(1);
    }

    #[inline]
    pub fn set_cache_size(&self, enrichment_type: &str, size: usize) {
        let key = if self.namespace.is_empty() {
            "enrichment_cache_size".to_string()
        } else {
            format!("{}_enrichment_cache_size", self.namespace)
        };
        metrics::gauge!(key, "type" => enrichment_type.to_string()).set(size as f64);
    }

    #[inline]
    pub fn record_duration(&self, enrichment_type: &str, seconds: f64) {
        let key = if self.namespace.is_empty() {
            "enrichment_duration_seconds".to_string()
        } else {
            format!("{}_enrichment_duration_seconds", self.namespace)
        };
        metrics::histogram!(key, "type" => enrichment_type.to_string()).record(seconds);
    }
}