env_filter/
parser.rs

Help
1use log::LevelFilter;
2use std::error::Error;
3use std::fmt::{Display, Formatter};
4
5use crate::Directive;
6use crate::FilterOp;
7
8#[derive(Default, Debug)]
9pub(crate) struct ParseResult {
10    pub(crate) directives: Vec<Directive>,
11    pub(crate) filter: Option<FilterOp>,
12    pub(crate) errors: Vec<String>,
13}
14
15impl ParseResult {
16    fn add_directive(&mut self, directive: Directive) {
17        self.directives.push(directive);
18    }
19
20    fn set_filter(&mut self, filter: FilterOp) {
21        self.filter = Some(filter);
22    }
23
24    fn add_error(&mut self, message: String) {
25        self.errors.push(message);
26    }
27
28    pub(crate) fn ok(self) -> Result<(Vec<Directive>, Option<FilterOp>), ParseError> {
29        let Self {
30            directives,
31            filter,
32            errors,
33        } = self;
34        if let Some(error) = errors.into_iter().next() {
35            Err(ParseError { details: error })
36        } else {
37            Ok((directives, filter))
38        }
39    }
40}
41
42/// Error during logger directive parsing process.
43#[derive(Debug, Clone, PartialEq, Eq, Hash)]
44pub struct ParseError {
45    details: String,
46}
47
48impl Display for ParseError {
49    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
50        write!(f, "error parsing logger filter: {}", self.details)
51    }
52}
53
54impl Error for ParseError {}
55
56/// Parse a logging specification string (e.g: `crate1,crate2::mod3,crate3::x=error/foo`)
57/// and return a vector with log directives.
58pub(crate) fn parse_spec(spec: &str) -> ParseResult {
59    let mut result = ParseResult::default();
60
61    let mut parts = spec.split('/');
62    let mods = parts.next();
63    let filter = parts.next();
64    if parts.next().is_some() {
65        result.add_error(format!("invalid logging spec '{spec}' (too many '/'s)"));
66        return result;
67    }
68    if let Some(m) = mods {
69        for s in m.split(',').map(|ss| ss.trim()) {
70            if s.is_empty() {
71                continue;
72            }
73            let mut parts = s.split('=');
74            let (log_level, name) =
75                match (parts.next(), parts.next().map(|s| s.trim()), parts.next()) {
76                    (Some(part0), None, None) => {
77                        // if the single argument is a log-level string or number,
78                        // treat that as a global fallback
79                        match part0.parse() {
80                            Ok(num) => (num, None),
81                            Err(_) => (LevelFilter::max(), Some(part0)),
82                        }
83                    }
84                    (Some(part0), Some(""), None) => (LevelFilter::max(), Some(part0)),
85                    (Some(part0), Some(part1), None) => {
86                        if let Ok(num) = part1.parse() {
87                            (num, Some(part0))
88                        } else {
89                            result.add_error(format!("invalid logging spec '{part1}'"));
90                            continue;
91                        }
92                    }
93                    _ => {
94                        result.add_error(format!("invalid logging spec '{s}'"));
95                        continue;
96                    }
97                };
98
99            result.add_directive(Directive {
100                name: name.map(|s| s.to_owned()),
101                level: log_level,
102            });
103        }
104    }
105
106    if let Some(filter) = filter {
107        match FilterOp::new(filter) {
108            Ok(filter_op) => result.set_filter(filter_op),
109            Err(err) => result.add_error(format!("invalid regex filter - {err}")),
110        }
111    }
112
113    result
114}
115
116#[cfg(test)]
117mod tests {
118    use crate::ParseError;
119    use log::LevelFilter;
120    use snapbox::{assert_data_eq, str, Data, IntoData};
121
122    use super::{parse_spec, ParseResult};
123
124    impl IntoData for ParseError {
125        fn into_data(self) -> Data {
126            self.to_string().into_data()
127        }
128    }
129
130    #[test]
131    fn parse_spec_valid() {
132        let ParseResult {
133            directives: dirs,
134            filter,
135            errors,
136        } = parse_spec("crate1::mod1=error,crate1::mod2,crate2=debug");
137
138        assert_eq!(dirs.len(), 3);
139        assert_eq!(dirs[0].name, Some("crate1::mod1".to_owned()));
140        assert_eq!(dirs[0].level, LevelFilter::Error);
141
142        assert_eq!(dirs[1].name, Some("crate1::mod2".to_owned()));
143        assert_eq!(dirs[1].level, LevelFilter::max());
144
145        assert_eq!(dirs[2].name, Some("crate2".to_owned()));
146        assert_eq!(dirs[2].level, LevelFilter::Debug);
147        assert!(filter.is_none());
148
149        assert!(errors.is_empty());
150    }
151
152    #[test]
153    fn parse_spec_invalid_crate() {
154        // test parse_spec with multiple = in specification
155        let ParseResult {
156            directives: dirs,
157            filter,
158            errors,
159        } = parse_spec("crate1::mod1=warn=info,crate2=debug");
160
161        assert_eq!(dirs.len(), 1);
162        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
163        assert_eq!(dirs[0].level, LevelFilter::Debug);
164        assert!(filter.is_none());
165
166        assert_eq!(errors.len(), 1);
167        assert_data_eq!(
168            &errors[0],
169            str!["invalid logging spec 'crate1::mod1=warn=info'"]
170        );
171    }
172
173    #[test]
174    fn parse_spec_invalid_level() {
175        // test parse_spec with 'noNumber' as log level
176        let ParseResult {
177            directives: dirs,
178            filter,
179            errors,
180        } = parse_spec("crate1::mod1=noNumber,crate2=debug");
181
182        assert_eq!(dirs.len(), 1);
183        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
184        assert_eq!(dirs[0].level, LevelFilter::Debug);
185        assert!(filter.is_none());
186
187        assert_eq!(errors.len(), 1);
188        assert_data_eq!(&errors[0], str!["invalid logging spec 'noNumber'"]);
189    }
190
191    #[test]
192    fn parse_spec_string_level() {
193        // test parse_spec with 'warn' as log level
194        let ParseResult {
195            directives: dirs,
196            filter,
197            errors,
198        } = parse_spec("crate1::mod1=wrong,crate2=warn");
199
200        assert_eq!(dirs.len(), 1);
201        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
202        assert_eq!(dirs[0].level, LevelFilter::Warn);
203        assert!(filter.is_none());
204
205        assert_eq!(errors.len(), 1);
206        assert_data_eq!(&errors[0], str!["invalid logging spec 'wrong'"]);
207    }
208
209    #[test]
210    fn parse_spec_empty_level() {
211        // test parse_spec with '' as log level
212        let ParseResult {
213            directives: dirs,
214            filter,
215            errors,
216        } = parse_spec("crate1::mod1=wrong,crate2=");
217
218        assert_eq!(dirs.len(), 1);
219        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
220        assert_eq!(dirs[0].level, LevelFilter::max());
221        assert!(filter.is_none());
222
223        assert_eq!(errors.len(), 1);
224        assert_data_eq!(&errors[0], str!["invalid logging spec 'wrong'"]);
225    }
226
227    #[test]
228    fn parse_spec_empty_level_isolated() {
229        // test parse_spec with "" as log level (and the entire spec str)
230        let ParseResult {
231            directives: dirs,
232            filter,
233            errors,
234        } = parse_spec(""); // should be ignored
235        assert_eq!(dirs.len(), 0);
236        assert!(filter.is_none());
237        assert!(errors.is_empty());
238    }
239
240    #[test]
241    fn parse_spec_blank_level_isolated() {
242        // test parse_spec with a white-space-only string specified as the log
243        // level (and the entire spec str)
244        let ParseResult {
245            directives: dirs,
246            filter,
247            errors,
248        } = parse_spec("     "); // should be ignored
249        assert_eq!(dirs.len(), 0);
250        assert!(filter.is_none());
251        assert!(errors.is_empty());
252    }
253
254    #[test]
255    fn parse_spec_blank_level_isolated_comma_only() {
256        // The spec should contain zero or more comma-separated string slices,
257        // so a comma-only string should be interpreted as two empty strings
258        // (which should both be treated as invalid, so ignored).
259        let ParseResult {
260            directives: dirs,
261            filter,
262            errors,
263        } = parse_spec(","); // should be ignored
264        assert_eq!(dirs.len(), 0);
265        assert!(filter.is_none());
266        assert!(errors.is_empty());
267    }
268
269    #[test]
270    fn parse_spec_blank_level_isolated_comma_blank() {
271        // The spec should contain zero or more comma-separated string slices,
272        // so this bogus spec should be interpreted as containing one empty
273        // string and one blank string. Both should both be treated as
274        // invalid, so ignored.
275        let ParseResult {
276            directives: dirs,
277            filter,
278            errors,
279        } = parse_spec(",     "); // should be ignored
280        assert_eq!(dirs.len(), 0);
281        assert!(filter.is_none());
282        assert!(errors.is_empty());
283    }
284
285    #[test]
286    fn parse_spec_blank_level_isolated_blank_comma() {
287        // The spec should contain zero or more comma-separated string slices,
288        // so this bogus spec should be interpreted as containing one blank
289        // string and one empty string. Both should both be treated as
290        // invalid, so ignored.
291        let ParseResult {
292            directives: dirs,
293            filter,
294            errors,
295        } = parse_spec("     ,"); // should be ignored
296        assert_eq!(dirs.len(), 0);
297        assert!(filter.is_none());
298        assert!(errors.is_empty());
299    }
300
301    #[test]
302    fn parse_spec_global() {
303        // test parse_spec with no crate
304        let ParseResult {
305            directives: dirs,
306            filter,
307            errors,
308        } = parse_spec("warn,crate2=debug");
309        assert_eq!(dirs.len(), 2);
310        assert_eq!(dirs[0].name, None);
311        assert_eq!(dirs[0].level, LevelFilter::Warn);
312        assert_eq!(dirs[1].name, Some("crate2".to_owned()));
313        assert_eq!(dirs[1].level, LevelFilter::Debug);
314        assert!(filter.is_none());
315        assert!(errors.is_empty());
316    }
317
318    #[test]
319    fn parse_spec_global_bare_warn_lc() {
320        // test parse_spec with no crate, in isolation, all lowercase
321        let ParseResult {
322            directives: dirs,
323            filter,
324            errors,
325        } = parse_spec("warn");
326        assert_eq!(dirs.len(), 1);
327        assert_eq!(dirs[0].name, None);
328        assert_eq!(dirs[0].level, LevelFilter::Warn);
329        assert!(filter.is_none());
330        assert!(errors.is_empty());
331    }
332
333    #[test]
334    fn parse_spec_global_bare_warn_uc() {
335        // test parse_spec with no crate, in isolation, all uppercase
336        let ParseResult {
337            directives: dirs,
338            filter,
339            errors,
340        } = parse_spec("WARN");
341        assert_eq!(dirs.len(), 1);
342        assert_eq!(dirs[0].name, None);
343        assert_eq!(dirs[0].level, LevelFilter::Warn);
344        assert!(filter.is_none());
345        assert!(errors.is_empty());
346    }
347
348    #[test]
349    fn parse_spec_global_bare_warn_mixed() {
350        // test parse_spec with no crate, in isolation, mixed case
351        let ParseResult {
352            directives: dirs,
353            filter,
354            errors,
355        } = parse_spec("wArN");
356        assert_eq!(dirs.len(), 1);
357        assert_eq!(dirs[0].name, None);
358        assert_eq!(dirs[0].level, LevelFilter::Warn);
359        assert!(filter.is_none());
360        assert!(errors.is_empty());
361    }
362
363    #[test]
364    fn parse_spec_valid_filter() {
365        let ParseResult {
366            directives: dirs,
367            filter,
368            errors,
369        } = parse_spec("crate1::mod1=error,crate1::mod2,crate2=debug/abc");
370        assert_eq!(dirs.len(), 3);
371        assert_eq!(dirs[0].name, Some("crate1::mod1".to_owned()));
372        assert_eq!(dirs[0].level, LevelFilter::Error);
373
374        assert_eq!(dirs[1].name, Some("crate1::mod2".to_owned()));
375        assert_eq!(dirs[1].level, LevelFilter::max());
376
377        assert_eq!(dirs[2].name, Some("crate2".to_owned()));
378        assert_eq!(dirs[2].level, LevelFilter::Debug);
379        assert!(filter.is_some() && filter.unwrap().to_string() == "abc");
380        assert!(errors.is_empty());
381    }
382
383    #[test]
384    fn parse_spec_invalid_crate_filter() {
385        let ParseResult {
386            directives: dirs,
387            filter,
388            errors,
389        } = parse_spec("crate1::mod1=error=warn,crate2=debug/a.c");
390
391        assert_eq!(dirs.len(), 1);
392        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
393        assert_eq!(dirs[0].level, LevelFilter::Debug);
394        assert!(filter.is_some() && filter.unwrap().to_string() == "a.c");
395
396        assert_eq!(errors.len(), 1);
397        assert_data_eq!(
398            &errors[0],
399            str!["invalid logging spec 'crate1::mod1=error=warn'"]
400        );
401    }
402
403    #[test]
404    fn parse_spec_empty_with_filter() {
405        let ParseResult {
406            directives: dirs,
407            filter,
408            errors,
409        } = parse_spec("crate1/a*c");
410        assert_eq!(dirs.len(), 1);
411        assert_eq!(dirs[0].name, Some("crate1".to_owned()));
412        assert_eq!(dirs[0].level, LevelFilter::max());
413        assert!(filter.is_some() && filter.unwrap().to_string() == "a*c");
414        assert!(errors.is_empty());
415    }
416
417    #[test]
418    fn parse_spec_with_multiple_filters() {
419        let ParseResult {
420            directives: dirs,
421            filter,
422            errors,
423        } = parse_spec("debug/abc/a.c");
424        assert!(dirs.is_empty());
425        assert!(filter.is_none());
426
427        assert_eq!(errors.len(), 1);
428        assert_data_eq!(
429            &errors[0],
430            str!["invalid logging spec 'debug/abc/a.c' (too many '/'s)"]
431        );
432    }
433
434    #[test]
435    fn parse_spec_multiple_invalid_crates() {
436        // test parse_spec with multiple = in specification
437        let ParseResult {
438            directives: dirs,
439            filter,
440            errors,
441        } = parse_spec("crate1::mod1=warn=info,crate2=debug,crate3=error=error");
442
443        assert_eq!(dirs.len(), 1);
444        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
445        assert_eq!(dirs[0].level, LevelFilter::Debug);
446        assert!(filter.is_none());
447
448        assert_eq!(errors.len(), 2);
449        assert_data_eq!(
450            &errors[0],
451            str!["invalid logging spec 'crate1::mod1=warn=info'"]
452        );
453        assert_data_eq!(
454            &errors[1],
455            str!["invalid logging spec 'crate3=error=error'"]
456        );
457    }
458
459    #[test]
460    fn parse_spec_multiple_invalid_levels() {
461        // test parse_spec with 'noNumber' as log level
462        let ParseResult {
463            directives: dirs,
464            filter,
465            errors,
466        } = parse_spec("crate1::mod1=noNumber,crate2=debug,crate3=invalid");
467
468        assert_eq!(dirs.len(), 1);
469        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
470        assert_eq!(dirs[0].level, LevelFilter::Debug);
471        assert!(filter.is_none());
472
473        assert_eq!(errors.len(), 2);
474        assert_data_eq!(&errors[0], str!["invalid logging spec 'noNumber'"]);
475        assert_data_eq!(&errors[1], str!["invalid logging spec 'invalid'"]);
476    }
477
478    #[test]
479    fn parse_spec_invalid_crate_and_level() {
480        // test parse_spec with 'noNumber' as log level
481        let ParseResult {
482            directives: dirs,
483            filter,
484            errors,
485        } = parse_spec("crate1::mod1=debug=info,crate2=debug,crate3=invalid");
486
487        assert_eq!(dirs.len(), 1);
488        assert_eq!(dirs[0].name, Some("crate2".to_owned()));
489        assert_eq!(dirs[0].level, LevelFilter::Debug);
490        assert!(filter.is_none());
491
492        assert_eq!(errors.len(), 2);
493        assert_data_eq!(
494            &errors[0],
495            str!["invalid logging spec 'crate1::mod1=debug=info'"]
496        );
497        assert_data_eq!(&errors[1], str!["invalid logging spec 'invalid'"]);
498    }
499
500    #[test]
501    fn parse_error_message_single_error() {
502        let error = parse_spec("crate1::mod1=debug=info,crate2=debug")
503            .ok()
504            .unwrap_err();
505        assert_data_eq!(
506            error,
507            str!["error parsing logger filter: invalid logging spec 'crate1::mod1=debug=info'"]
508        );
509    }
510
511    #[test]
512    fn parse_error_message_multiple_errors() {
513        let error = parse_spec("crate1::mod1=debug=info,crate2=debug,crate3=invalid")
514            .ok()
515            .unwrap_err();
516        assert_data_eq!(
517            error,
518            str!["error parsing logger filter: invalid logging spec 'crate1::mod1=debug=info'"]
519        );
520    }
521}
env_filter/parser.rs

env_filter/
parser.rs
