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 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
/// Logging handle used to execute logging statements /// /// Logger handles logging context (key-value list) and handles logging /// statements. /// /// Child loggers are build from existing loggers, and inherit existing /// key-value pairs from their parents, which can be supplemented with /// new ones. /// /// Cloning existing loggers and creating new ones is cheap. Loggers can be /// freely passed around the code. #[derive(Clone)] pub struct Logger { drain: Arc<Drain<Error=Never>>, values: Arc<OwnedKeyValueList>, } impl Logger { /// Build a root `Logger` /// /// All children and their children and so on form one hierarchy /// sharing a common drain. /// /// Root logger starts a new hierarchy associated with a given `Drain`. Root /// logger drain must return no errors. See `DrainExt::ignore_err()` and /// /// `DrainExt::fuse()`. /// Use `o!` macro to help build key-value pairs with a nicer syntax. /// /// ``` /// #[macro_use] /// extern crate slog; /// /// fn main() { /// let root = slog::Logger::root( /// slog::Discard, /// o!("key1" => "value1", "key2" => "value2"), /// ); /// } pub fn root<D: 'static + Drain<Error=Never> + Sized>(d: D, values: Vec<OwnedKeyValue>) -> Logger { Logger { drain: Arc::new(d), values: Arc::new(OwnedKeyValueList::root(values)), } } /// Build a child logger /// /// Child logger inherits all existing key-value pairs from it's parent. /// /// All children, their children and so on, form one hierarchy sharing /// a common drain. /// /// Use `o!` macro to help build key value pairs using nicer syntax. /// /// ``` /// #[macro_use] /// extern crate slog; /// /// fn main() { /// let root = slog::Logger::root(slog::Discard, /// o!("key1" => "value1", "key2" => "value2")); /// let log = root.new(o!("key" => "value")); /// } pub fn new(&self, values: Vec<OwnedKeyValue>) -> Logger { Logger { drain: self.drain.clone(), values: Arc::new(OwnedKeyValueList::new(values, self.values.clone())), } } /// Log one logging record /// /// Use specific logging functions instead. See `log!` macro /// documentation. #[inline] pub fn log(&self, record: &Record) { let _ = self.drain.log(&record, &*self.values); } } #[doc(hidden)] pub struct RecordStatic<'a> { /// Logging level pub level: Level, /// File pub file: &'static str, /// Line pub line: u32, /// Column (currently not implemented) pub column: u32, /// Function (currently not implemented) pub function: &'static str, /// Module pub module: &'static str, /// Target - for backward compatibility with `log` pub target: &'a str, } /// One logging record /// /// Corresponds to one logging statement like `info!(...)` and carries all it's /// data: eg. message, key-values, key-values of `Logger` used to execute it. /// /// Record is passed to `Drain` associated with a given logger hierarchy. pub struct Record<'a> { meta: &'a RecordStatic<'a>, msg: fmt::Arguments<'a>, values: &'a [BorrowedKeyValue<'a>], } impl<'a> Record<'a> { /// Create a new `Record` #[inline] #[doc(hidden)] pub fn new( s : &'a RecordStatic<'a>, msg: fmt::Arguments<'a>, values: &'a [BorrowedKeyValue<'a>], ) -> Self { Record { meta: s, msg: msg, values: values, } } /// Get a log record message pub fn msg(&self) -> fmt::Arguments { self.msg } /// Get record logging level pub fn level(&self) -> Level { self.meta.level } /// Get line number pub fn line(&self) -> u32 { self.meta.line } /// Get error column pub fn column(&self) -> u32 { self.meta.column } /// Get file path pub fn file(&self) -> &'static str { self.meta.file } /// Get target /// /// Mostly for backward compatibility with `log` pub fn target(&self) -> &str { self.meta.target } /// Get module pub fn module(&self) -> &'static str { self.meta.module } /// Get function pub fn function(&self) -> &'static str { self.meta.function } /// Get Record's key-value pairs pub fn values(&self) -> &'a [BorrowedKeyValue<'a>] { self.values } }