sloggers/
config.rs

1#[cfg(not(unix))]
2use crate::fake_syslog::SyslogNotSupported;
3use crate::file::FileLoggerConfig;
4use crate::null::NullLoggerConfig;
5#[cfg(unix)]
6use crate::syslog::SyslogConfig;
7use crate::terminal::TerminalLoggerConfig;
8use crate::types::Severity;
9use crate::{Build, LoggerBuilder, Result};
10use serde::{Deserialize, Serialize};
11use slog::Logger;
12
13/// Configuration of a logger builder.
14pub trait Config {
15    /// Logger builder.
16    type Builder: Build;
17
18    /// Makes a logger builder associated with this configuration.
19    fn try_to_builder(&self) -> Result<Self::Builder>;
20
21    /// Builds a logger with this configuration.
22    fn build_logger(&self) -> Result<Logger> {
23        let builder = track!(self.try_to_builder())?;
24        let logger = track!(builder.build())?;
25        Ok(logger)
26    }
27}
28
29/// The configuration of `LoggerBuilder`.
30///
31/// # Examples
32///
33/// Null logger.
34///
35/// ```
36/// extern crate sloggers;
37/// extern crate serdeconv;
38///
39/// use sloggers::LoggerConfig;
40///
41/// let toml = r#"
42/// type = "null"
43/// "#;
44/// let _config: LoggerConfig = serdeconv::from_toml_str(toml).unwrap();
45/// ```
46///
47/// Terminal logger.
48///
49/// ```
50/// extern crate sloggers;
51/// extern crate serdeconv;
52///
53/// use sloggers::LoggerConfig;
54///
55/// let toml = r#"
56/// type = "terminal"
57/// level = "warning"
58/// "#;
59/// let _config: LoggerConfig = serdeconv::from_toml_str(toml).unwrap();
60/// ```
61///
62/// File logger.
63///
64/// ```
65/// extern crate sloggers;
66/// extern crate serdeconv;
67///
68/// use sloggers::LoggerConfig;
69///
70/// let toml = r#"
71/// type = "file"
72/// path = "/path/to/file.log"
73/// timezone = "utc"
74/// "#;
75/// let _config: LoggerConfig = serdeconv::from_toml_str(toml).unwrap();
76/// ```
77///
78/// Syslog logger. (Unix-like systems only.)
79///
80/// ```
81/// extern crate sloggers;
82/// extern crate serdeconv;
83///
84/// use sloggers::LoggerConfig;
85///
86/// let toml = r#"
87/// type = "syslog"
88/// facility = "daemon"
89/// "#;
90/// # #[cfg(unix)]
91/// let _config: LoggerConfig = serdeconv::from_toml_str(toml).unwrap();
92/// # #[cfg(not(unix))] {
93/// #     use std::error::Error as StdError;
94/// #     assert!(
95/// #         serdeconv::from_toml_str::<LoggerConfig>(toml)
96/// #         .expect_err("deserializing the configuration should have failed")
97/// #         .to_string()
98/// #         .contains("syslog is not supported")
99/// #     );
100/// # }
101/// ```
102#[allow(missing_docs)]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(tag = "type")]
105#[serde(rename_all = "lowercase")]
106#[non_exhaustive]
107pub enum LoggerConfig {
108    File(FileLoggerConfig),
109    Null(NullLoggerConfig),
110    #[cfg(unix)]
111    Syslog(SyslogConfig),
112    #[cfg(not(unix))]
113    #[doc(hidden)]
114    Syslog(SyslogNotSupported),
115    Terminal(TerminalLoggerConfig),
116}
117impl LoggerConfig {
118    /// Sets the log level of this logger.
119    pub fn set_loglevel(&mut self, level: Severity) {
120        match *self {
121            LoggerConfig::File(ref mut c) => c.level = level,
122            LoggerConfig::Null(_) => {}
123            #[cfg(unix)]
124            LoggerConfig::Syslog(ref mut c) => c.level = level,
125            #[cfg(not(unix))]
126            LoggerConfig::Syslog(_) => unreachable!(),
127            LoggerConfig::Terminal(ref mut c) => c.level = level,
128        }
129    }
130}
131impl Config for LoggerConfig {
132    type Builder = LoggerBuilder;
133    fn try_to_builder(&self) -> Result<Self::Builder> {
134        match *self {
135            LoggerConfig::File(ref c) => track!(c.try_to_builder()).map(LoggerBuilder::File),
136            LoggerConfig::Null(ref c) => track!(c.try_to_builder()).map(LoggerBuilder::Null),
137            #[cfg(unix)]
138            LoggerConfig::Syslog(ref c) => track!(c.try_to_builder()).map(LoggerBuilder::Syslog),
139            #[cfg(not(unix))]
140            LoggerConfig::Syslog(_) => unreachable!(),
141            LoggerConfig::Terminal(ref c) => {
142                track!(c.try_to_builder()).map(LoggerBuilder::Terminal)
143            }
144        }
145    }
146}
147impl Default for LoggerConfig {
148    fn default() -> Self {
149        LoggerConfig::Terminal(TerminalLoggerConfig::default())
150    }
151}