foundations 5.6.5

A Rust service foundations library.
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
127
128
129

use crate::telemetry::log::init::{LogHarness, build_log_with_drain, wrap_root_drain};
use crate::telemetry::log::internal::LoggerWithKvNestingTracking;
use crate::telemetry::settings::LoggingSettings;
use parking_lot::RwLock as ParkingRwLock;
use slog::{Discard, Drain, KV, Key, Level, Never, OwnedKVList, Record, Serializer};
use std::fmt::Arguments;
use std::sync::{Arc, RwLock};

pub(crate) type TestLogRecords = Arc<RwLock<Vec<TestLogRecord>>>;

/// Log record produced in the [test telemetry context].
///
/// [test telemetry context]: crate::telemetry::TelemetryContext::test
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TestLogRecord {
    /// Verbosity level of the log record.
    pub level: Level,

    /// Log message.
    pub message: String,

    /// Log record fields.
    pub fields: Vec<(String, String)>,
}

#[derive(Default)]
struct TestFieldSerializer {
    fields: Vec<(String, String)>,
}

impl Serializer for TestFieldSerializer {
    fn emit_arguments(&mut self, key: Key, val: &Arguments) -> slog::Result {
        self.fields.push((key.to_string(), val.to_string()));

        Ok(())
    }
}

struct TestLogDrain<D> {
    records: TestLogRecords,
    /// Optional drain to forward logs to after recording in the test log
    forward: Option<D>,
}

impl<D> Drain for TestLogDrain<D>
where
    D: Drain<Ok = (), Err = Never>,
{
    type Ok = ();
    type Err = Never;

    fn log(&self, record: &Record, kv: &OwnedKVList) -> Result<Self::Ok, Self::Err> {
        let mut serializer = TestFieldSerializer::default();

        kv.serialize(record, &mut serializer).unwrap();
        record.kv().serialize(record, &mut serializer).unwrap();

        self.records.write().unwrap().push(TestLogRecord {
            level: record.level(),
            message: format!("{}", record.msg()),
            fields: serializer.fields,
        });

        if let Some(forward_drain) = &self.forward {
            let _ = forward_drain.log(record, kv);
        }

        Ok(())
    }
}

pub(crate) fn create_test_log(
    settings: &LoggingSettings,
) -> (LoggerWithKvNestingTracking, TestLogRecords) {
    let log_records = Arc::new(RwLock::new(vec![]));

    let drain: TestLogDrain<Discard> = TestLogDrain {
        records: Arc::clone(&log_records),
        forward: None,
    };
    let drain = wrap_root_drain(settings, drain);

    let logger = build_log_with_drain(settings.verbosity, slog::o!(), Arc::clone(&drain));
    let log = LoggerWithKvNestingTracking::new(logger);

    let _ = LogHarness::override_for_testing(LogHarness {
        root_log: Arc::new(ParkingRwLock::new(log.clone())),
        root_drain: drain,
        settings: settings.clone(),
        log_scope_stack: Default::default(),
    });

    (log, log_records)
}

/// Create a test log with a tracing-rs compat drain installed in addition to the test drain
#[cfg(feature = "tracing-rs-compat")]
pub(crate) fn create_test_log_for_tracing_compat(
    settings: &LoggingSettings,
) -> (LoggerWithKvNestingTracking, TestLogRecords) {
    use tracing_slog::TracingSlogDrain;

    assert!(matches!(
        settings.output,
        crate::telemetry::settings::LogOutput::TracingRsCompat
    ));

    let base_drain = TracingSlogDrain {};

    let log_records = Arc::new(RwLock::new(vec![]));

    let drain = TestLogDrain {
        records: Arc::clone(&log_records),
        forward: Some(base_drain.fuse()),
    };
    let drain = wrap_root_drain(settings, drain);

    let logger = build_log_with_drain(settings.verbosity, slog::o!(), Arc::clone(&drain));
    let log = LoggerWithKvNestingTracking::new(logger);

    let _ = LogHarness::override_for_testing(LogHarness {
        root_log: Arc::new(ParkingRwLock::new(log.clone())),
        root_drain: drain,
        settings: settings.clone(),
        log_scope_stack: Default::default(),
    });

    (log, log_records)
}