stackable_telemetry/tracing/settings/
mod.rs

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
135
136
137
138
139
140
141
142
143
144
145
146
147
//! Subscriber settings.

use std::path::Path;

use tracing::level_filters::LevelFilter;

pub mod console_log;
pub use console_log::*;

pub mod file_log;
pub use file_log::*;

pub mod otlp_log;
pub use otlp_log::*;

pub mod otlp_trace;
pub use otlp_trace::*;

/// Indicate whether a type is enabled or disabled.
pub trait SettingsToggle {
    /// Whether the settings are enabled or not.
    fn is_enabled(&self) -> bool;

    /// The opposite of [SettingsToggle::is_enabled] as a helper.
    fn is_disabled(&self) -> bool {
        !self.is_enabled()
    }
}

/// General settings that apply to any subscriber.
#[derive(Debug, PartialEq)]
pub struct Settings {
    /// The environment variable used to set the [`LevelFilter`].
    ///
    /// When the environment variable is set, it will override what is set by
    /// [`Self::default_level`].
    pub environment_variable: &'static str,

    /// The [`LevelFilter`] to fallback to if [`Self::environment_variable`] has
    /// not been set.
    pub default_level: LevelFilter,
}

impl Settings {
    /// Builder methods to override defaults.
    pub fn builder() -> SettingsBuilder {
        SettingsBuilder::default()
    }
}

impl Default for Settings {
    fn default() -> Self {
        SettingsBuilder::default().build()
    }
}

/// For building [`Settings`].
pub struct SettingsBuilder {
    environment_variable: &'static str,
    default_level: LevelFilter,
}

impl SettingsBuilder {
    /// Set the environment variable used for overriding the [`Settings::default_level`].
    ///
    /// Defaults to `RUST_LOG`.
    // TODO (@NickLarsenNZ): set a constant for the default environment variable.
    pub fn with_environment_variable(mut self, name: &'static str) -> Self {
        self.environment_variable = name;
        self
    }

    /// Set the default [`LevelFilter`].
    ///
    /// Defaults to [`LevelFilter::OFF`].
    // TODO (@NickLarsenNZ): set a constant for the default level.
    pub fn with_default_level(mut self, level: impl Into<LevelFilter>) -> Self {
        self.default_level = level.into();
        self
    }

    /// Set specific [`ConsoleLogSettings`].
    pub fn console_log_settings_builder(self) -> ConsoleLogSettingsBuilder {
        self.into()
    }

    /// Set specific [`FileLogSettings`].
    pub fn file_log_settings_builder(
        self,
        path: impl AsRef<Path>,
        filename_suffix: impl Into<String>,
    ) -> FileLogSettingsBuilder {
        FileLogSettingsBuilder {
            common_settings: self.build(),
            file_log_dir: path.as_ref().to_path_buf(),
            rotation_period: Rotation::NEVER,
            filename_suffix: filename_suffix.into(),
            max_log_files: None,
        }
    }

    /// Set specific [`OtlpLogSettings`].
    pub fn otlp_log_settings_builder(self) -> OtlpLogSettingsBuilder {
        self.into()
    }

    /// Set specific [`OtlpTraceSettings`].
    pub fn otlp_trace_settings_builder(self) -> OtlpTraceSettingsBuilder {
        self.into()
    }

    /// Consumes self and constructs valid [`Settings`].
    pub fn build(self) -> Settings {
        Settings {
            environment_variable: self.environment_variable,
            default_level: self.default_level,
        }
    }
}

impl Default for SettingsBuilder {
    fn default() -> Self {
        Self {
            environment_variable: "RUST_LOG",
            default_level: LevelFilter::OFF,
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn builds_settings() {
        let expected = Settings {
            environment_variable: "hello",
            default_level: LevelFilter::DEBUG,
        };
        let result = Settings::builder()
            .with_environment_variable("hello")
            .with_default_level(LevelFilter::DEBUG)
            .build();

        assert_eq!(expected, result);
    }
}