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

use crate::layers::Layer;
use metrics::{GaugeValue, Key, Recorder, SharedString, Unit};

/// Applies a prefix to every metric key.
///
/// Keys will be prefixed in the format of `<prefix>.<remaining>`.
pub struct Prefix<R> {
    prefix: SharedString,
    inner: R,
}

impl<R> Prefix<R> {
    fn prefix_key(&self, key: Key) -> Key {
        key.into_owned().prepend_name(self.prefix.clone()).into()
    }
}

impl<R: Recorder> Recorder for Prefix<R> {
    fn register_counter(&self, key: Key, unit: Option<Unit>, description: Option<&'static str>) {
        let new_key = self.prefix_key(key);
        self.inner.register_counter(new_key, unit, description)
    }

    fn register_gauge(&self, key: Key, unit: Option<Unit>, description: Option<&'static str>) {
        let new_key = self.prefix_key(key);
        self.inner.register_gauge(new_key, unit, description)
    }

    fn register_histogram(&self, key: Key, unit: Option<Unit>, description: Option<&'static str>) {
        let new_key = self.prefix_key(key);
        self.inner.register_histogram(new_key, unit, description)
    }

    fn increment_counter(&self, key: Key, value: u64) {
        let new_key = self.prefix_key(key);
        self.inner.increment_counter(new_key, value);
    }

    fn update_gauge(&self, key: Key, value: GaugeValue) {
        let new_key = self.prefix_key(key);
        self.inner.update_gauge(new_key, value);
    }

    fn record_histogram(&self, key: Key, value: f64) {
        let new_key = self.prefix_key(key);
        self.inner.record_histogram(new_key, value);
    }
}

/// A layer for applying a prefix to every metric key.
///
/// More information on the behavior of the layer can be found in [`Prefix`].
pub struct PrefixLayer(&'static str);

impl PrefixLayer {
    /// Creates a new `PrefixLayer` based on the given prefix.
    pub fn new<S: Into<String>>(prefix: S) -> PrefixLayer {
        PrefixLayer(Box::leak(prefix.into().into_boxed_str()))
    }
}

impl<R> Layer<R> for PrefixLayer {
    type Output = Prefix<R>;

    fn layer(&self, inner: R) -> Self::Output {
        Prefix {
            prefix: self.0.into(),
            inner,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::PrefixLayer;
    use crate::debugging::DebuggingRecorder;
    use crate::layers::Layer;
    use metrics::{KeyData, Recorder, Unit};

    #[test]
    fn test_basic_functionality() {
        let recorder = DebuggingRecorder::new();
        let snapshotter = recorder.snapshotter();
        let prefix = PrefixLayer::new("testing");
        let layered = prefix.layer(recorder);

        let before = snapshotter.snapshot();
        assert_eq!(before.len(), 0);

        let ud = &[
            (Unit::Nanoseconds, "counter desc"),
            (Unit::Microseconds, "gauge desc"),
            (Unit::Milliseconds, "histogram desc"),
        ];

        layered.register_counter(
            KeyData::from_name("counter_metric").into(),
            Some(ud[0].0.clone()),
            Some(ud[0].1),
        );
        layered.register_gauge(
            KeyData::from_name("gauge_metric").into(),
            Some(ud[1].0.clone()),
            Some(ud[1].1),
        );
        layered.register_histogram(
            KeyData::from_name("histogram_metric").into(),
            Some(ud[2].0.clone()),
            Some(ud[2].1),
        );

        let after = snapshotter.snapshot();
        assert_eq!(after.len(), 3);

        for (i, (key, unit, desc, _value)) in after.iter().enumerate() {
            assert!(key.key().name().to_string().starts_with("testing"));
            assert_eq!(&Some(ud[i].0.clone()), unit);
            assert_eq!(&Some(ud[i].1), desc);
        }
    }
}