prestige 0.2.5

Prestige file reading and writing utilities and tools
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

//! Implementation using opentelemetry crate
use super::Label;
use opentelemetry::{
    KeyValue, global,
    metrics::{Counter, Gauge, Histogram, Meter},
};
use std::{
    collections::HashMap,
    sync::{OnceLock, RwLock},
};

// ====================================================================
// Meter and Instrument Caching
// ====================================================================

static METER: OnceLock<Meter> = OnceLock::new();
static COUNTERS: OnceLock<RwLock<HashMap<&'static str, Counter<u64>>>> = OnceLock::new();
static HISTOGRAMS: OnceLock<RwLock<HashMap<&'static str, Histogram<f64>>>> = OnceLock::new();
static GAUGES: OnceLock<RwLock<HashMap<&'static str, Gauge<f64>>>> = OnceLock::new();

fn get_meter() -> &'static Meter {
    METER.get_or_init(|| global::meter("prestige"))
}

fn to_key_values(labels: &[Label]) -> Vec<KeyValue> {
    labels
        .iter()
        .map(|l| KeyValue::new(l.key, l.value.clone()))
        .collect()
}

// ====================================================================
// Counter Implementation
// ====================================================================

fn get_or_create_counter(name: &'static str) -> Counter<u64> {
    let counters = COUNTERS.get_or_init(|| RwLock::new(HashMap::new()));

    // Fast path; check if counter exists
    if let Ok(guard) = counters.read()
        && let Some(counter) = guard.get(name)
    {
        return counter.clone();
    }

    // Slow path: create counter
    let mut guard = counters.write().unwrap();
    guard
        .entry(name)
        .or_insert_with(|| get_meter().u64_counter(name).build())
        .clone()
}

/// Increment a counter metric
pub fn increment_counter(name: &'static str, value: u64, labels: &[Label]) {
    let counter = get_or_create_counter(name);
    let attrs = to_key_values(labels);
    counter.add(value, &attrs);
}

// ====================================================================
// Histogram Implementation
// ====================================================================

fn get_or_create_histogram(name: &'static str) -> Histogram<f64> {
    let histograms = HISTOGRAMS.get_or_init(|| RwLock::new(HashMap::new()));

    // Fast path: return already existing histogram
    if let Ok(guard) = histograms.read()
        && let Some(histogram) = guard.get(name)
    {
        return histogram.clone();
    }

    // Slow path: create new histogram
    let mut guard = histograms.write().unwrap();
    guard
        .entry(name)
        .or_insert_with(|| get_meter().f64_histogram(name).build())
        .clone()
}

/// Record a value to a histogram metric
pub fn record_histogram(name: &'static str, value: f64, labels: &[Label]) {
    let histogram = get_or_create_histogram(name);
    let attrs = to_key_values(labels);
    histogram.record(value, &attrs);
}

// ====================================================================
// Gauge Implementation
// ====================================================================

fn get_or_create_gauge(name: &'static str) -> Gauge<f64> {
    let gauges = GAUGES.get_or_init(|| RwLock::new(HashMap::new()));

    // Fast path: return already existing gauge
    if let Ok(guard) = gauges.read()
        && let Some(gauge) = guard.get(name)
    {
        return gauge.clone();
    }

    // Slow path: create and return a new gauge
    let mut guard = gauges.write().unwrap();
    guard
        .entry(name)
        .or_insert_with(|| get_meter().f64_gauge(name).build())
        .clone()
}

// Set a gauge metric value
pub fn set_gauge(name: &'static str, value: f64, labels: &[Label]) {
    let gauge = get_or_create_gauge(name);
    let attrs = to_key_values(labels);
    gauge.record(value, &attrs);
}