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 metrics::{GaugeValue, Key, Recorder, Unit};

/// Fans out metrics to multiple recorders.
pub struct Fanout {
    recorders: Vec<Box<dyn Recorder>>,
}

impl Recorder for Fanout {
    fn register_counter(&self, key: &Key, unit: Option<Unit>, description: Option<&'static str>) {
        for recorder in &self.recorders {
            recorder.register_counter(key, unit.clone(), description);
        }
    }

    fn register_gauge(&self, key: &Key, unit: Option<Unit>, description: Option<&'static str>) {
        for recorder in &self.recorders {
            recorder.register_gauge(key, unit.clone(), description);
        }
    }

    fn register_histogram(&self, key: &Key, unit: Option<Unit>, description: Option<&'static str>) {
        for recorder in &self.recorders {
            recorder.register_histogram(key, unit.clone(), description);
        }
    }

    fn increment_counter(&self, key: &Key, value: u64) {
        for recorder in &self.recorders {
            recorder.increment_counter(key, value);
        }
    }

    fn update_gauge(&self, key: &Key, value: GaugeValue) {
        for recorder in &self.recorders {
            recorder.update_gauge(key, value.clone());
        }
    }

    fn record_histogram(&self, key: &Key, value: f64) {
        for recorder in &self.recorders {
            recorder.record_histogram(key, value);
        }
    }
}

/// A layer for fanning out metrics to multiple recorders.
///
/// More information on the behavior of the layer can be found in [`Fanout`].
#[derive(Default)]
pub struct FanoutBuilder {
    recorders: Vec<Box<dyn Recorder>>,
}

impl FanoutBuilder {
    /// Adds a recorder to the fanout list.
    pub fn add_recorder<R>(mut self, recorder: R) -> FanoutBuilder
    where
        R: Recorder + 'static,
    {
        self.recorders.push(Box::new(recorder));
        self
    }

    /// Builds the `Fanout` layer.
    pub fn build(self) -> Fanout {
        Fanout {
            recorders: self.recorders,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::FanoutBuilder;
    use crate::debugging::DebuggingRecorder;
    use metrics::{GaugeValue, Recorder, Unit};

    #[test]
    fn test_basic_functionality() {
        let recorder1 = DebuggingRecorder::new();
        let snapshotter1 = recorder1.snapshotter();
        let recorder2 = DebuggingRecorder::new();
        let snapshotter2 = recorder2.snapshotter();
        let fanout = FanoutBuilder::default()
            .add_recorder(recorder1)
            .add_recorder(recorder2)
            .build();

        let tlkey = "tokio.loops".into();
        let hsbkey = "hyper.sent.bytes".into();

        let before1 = snapshotter1.snapshot();
        let before2 = snapshotter2.snapshot();
        assert_eq!(before1.len(), 0);
        assert_eq!(before2.len(), 0);

        let ud = &[(Unit::Count, "counter desc"), (Unit::Bytes, "gauge desc")];

        fanout.register_counter(&tlkey, Some(ud[0].0.clone()), Some(ud[0].1));
        fanout.register_gauge(&hsbkey, Some(ud[1].0.clone()), Some(ud[1].1));
        fanout.increment_counter(&tlkey, 47);
        fanout.update_gauge(&hsbkey, GaugeValue::Absolute(12.0));

        let after1 = snapshotter1.snapshot();
        let after2 = snapshotter2.snapshot();
        assert_eq!(after1.len(), 2);
        assert_eq!(after2.len(), 2);

        let after = after1
            .into_iter()
            .zip(after2)
            .enumerate()
            .collect::<Vec<_>>();

        for (i, ((k1, u1, d1, v1), (k2, u2, d2, v2))) in after {
            assert_eq!(k1, k2);
            assert_eq!(u1, u2);
            assert_eq!(d1, d2);
            assert_eq!(v1, v2);
            assert_eq!(Some(ud[i].0.clone()), u1);
            assert_eq!(Some(ud[i].0.clone()), u2);
            assert_eq!(Some(ud[i].1), d1);
            assert_eq!(Some(ud[i].1), d2);
        }
    }
}