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

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.clone(), 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.clone(), 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.clone(), unit.clone(), description);
        }
    }

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

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

    fn record_histogram(&self, key: Key, value: f64) {
        for recorder in &self.recorders {
            recorder.record_histogram(key.clone(), 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, Key, 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 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(
            Key::Owned("tokio.loops".into()),
            Some(ud[0].0.clone()),
            Some(ud[0].1),
        );
        fanout.register_gauge(
            Key::Owned("hyper.sent_bytes".into()),
            Some(ud[1].0.clone()),
            Some(ud[1].1),
        );
        fanout.increment_counter(Key::Owned("tokio.loops".into()), 47);
        fanout.update_gauge(
            Key::Owned("hyper.sent_bytes".into()),
            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);
        }
    }
}