rotonda 0.6.0

composable, programmable BGP engine
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

use std::{collections::HashMap, sync::{Arc, RwLock, atomic::{AtomicU64, Ordering}}};

use log::debug;

//pub type MutMetrics = Arc<RwLock<Metrics>>;
#[derive(Clone, Default)]
pub struct MutMetrics(Arc<RwLock<Metrics>>);

#[derive(Eq, Hash, PartialEq)]
pub struct MetricKey {
    name: String,
    tags: Vec<(String, String)>,
}


#[derive(Default)]
pub struct Metrics {
    counters: HashMap<String, AtomicU64>,
    gauges: HashMap<String, AtomicU64>,
}

impl PartialEq for MutMetrics {
    fn eq(&self, _other: &Self) -> bool {
        //XXX double check
        false
    }
}

impl MutMetrics {
    pub fn read(&self) -> std::result::Result<std::sync::RwLockReadGuard<'_, Metrics>, std::sync::PoisonError<std::sync::RwLockReadGuard<'_, Metrics>>> {
        self.0.read()
    }
    pub fn write(&self) -> std::result::Result<std::sync::RwLockWriteGuard<'_, Metrics>, std::sync::PoisonError<std::sync::RwLockWriteGuard<'_, Metrics>>> {
        self.0.write()
    }

}

impl Metrics {

    pub fn inc_counter(&mut self, name: impl AsRef<str>, value: u64) {
        self.counters.entry(name.as_ref().to_string()).and_modify(|counter| {
            counter.fetch_add(value, Ordering::Relaxed); 
        }).or_insert(value.into());
    }

    pub fn try_inc_counter(&self, name: impl AsRef<str>, value: u64) -> Result<(), &str> {
        if let Some(counter) = self.counters.get(name.as_ref()) {
            counter.fetch_add(value, Ordering::Relaxed);
            //debug!("inc_counter for {}, +{value}, now at {}",
            //    name,
            //    counter.load(Ordering::Relaxed)
            //);
            Ok(())
        } else {
            debug!("no counter {} yet (value: {value})", name.as_ref());
            Err("no key for this name in metrics")
        }
    }

    pub fn set_gauge(&mut self, name: impl AsRef<str>, value: u64) {
        self.gauges.entry(name.as_ref().to_string()).and_modify(|gauge| {
            gauge.store(value, Ordering::Relaxed); 
        }).or_insert(value.into());
    }

    pub fn try_set_gauge(&self, name: impl AsRef<str>, value: u64) -> Result<(), &str> {
        if let Some(gauge) = self.gauges.get(name.as_ref()) {
            gauge.store(value, Ordering::Relaxed);
            Ok(())
        } else {
            debug!("could not gauge {}, returning Err", name.as_ref());
            Err("no key for this name in metrics")
        }
    }
}

//impl crate::metrics::Source for Metrics {
//    fn append(&self, _unit_name: &str, target: &mut crate::metrics::Target) {
//        for (k,v) in self.counters.iter() {
//            target.append_raw(format!("roto_user_defined_{} {}", k, v.load(Ordering::Relaxed)));
//        }
//    }
//}

#[derive(Default)]
pub struct RotoMetricsWrapper {
    pub metrics: MutMetrics,
}

impl crate::metrics::Source for RotoMetricsWrapper {
    fn append(&self, _unit_name: &str, target: &mut crate::metrics::Target) {
        let mut counters;
        let mut gauges;
        {
            let metrics = self.metrics.read().unwrap();
            counters = metrics.counters.iter().map(|(k,v)| (k.to_string(), v.load(Ordering::Relaxed))).collect::<Vec<_>>();
            gauges = metrics.gauges.iter().map(|(k,v)| (k.to_string(), v.load(Ordering::Relaxed))).collect::<Vec<_>>();
        }
        counters.sort_by(|a, b| a.0.cmp(&b.0));
        gauges.sort_by(|a, b| a.0.cmp(&b.0));

        let mut printed_counter_names: Vec<String> = vec![];
        let mut printed_gauge_names: Vec<String> = vec![];

        for (name, cnt) in counters {
            let base_name: String = name.split('{').next().unwrap().into();
            if !printed_counter_names.contains(&base_name) {
                target.append_raw(format!("# TYPE roto_user_defined_{base_name} counter"));
                printed_counter_names.push(base_name);
            }

            target.append_raw(format!("roto_user_defined_{} {}", name, cnt));
        }
        for (name, val) in gauges {
            let base_name: String = name.split('{').next().unwrap().into();
            if !printed_gauge_names.contains(&base_name) {
                target.append_raw(format!("# TYPE {base_name} gauge"));
                printed_gauge_names.push(base_name);
            }

            target.append_raw(format!("roto_user_defined_{} {}", name, val));
        }
    }
}