lognorm 0.2.1

Automatic structured log normalization with preserved application fields
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

/// Common severity bands, ordered from least to most severe.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Severity {
    /// Detailed diagnostic information.
    Trace,
    /// Debugging information.
    Debug,
    /// Normal operational information.
    Info,
    /// A condition that may need attention.
    Warn,
    /// An operation failed.
    Error,
    /// A fatal condition.
    Fatal,
}

impl Severity {
    /// Canonical uppercase spelling of the severity band.
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Trace => "TRACE",
            Self::Debug => "DEBUG",
            Self::Info => "INFO",
            Self::Warn => "WARN",
            Self::Error => "ERROR",
            Self::Fatal => "FATAL",
        }
    }
}

pub(crate) fn name(value: &str) -> Option<Severity> {
    let value = value.trim();
    [
        (Severity::Trace, &["trace", "trc"][..]),
        (Severity::Debug, &["debug", "dbg"]),
        (
            Severity::Info,
            &["info", "information", "informational", "notice"],
        ),
        (Severity::Warn, &["warn", "warning", "wrn"]),
        (Severity::Error, &["error", "err", "exception"]),
        (
            Severity::Fatal,
            &["fatal", "critical", "crit", "panic", "emergency"],
        ),
    ]
    .into_iter()
    .find_map(|(severity, aliases)| {
        aliases
            .iter()
            .any(|alias| value.eq_ignore_ascii_case(alias))
            .then_some(severity)
    })
}

pub(crate) fn pino(value: i64) -> Option<Severity> {
    match value {
        10 => Some(Severity::Trace),
        20 => Some(Severity::Debug),
        30 => Some(Severity::Info),
        40 => Some(Severity::Warn),
        50 => Some(Severity::Error),
        60 => Some(Severity::Fatal),
        _ => None,
    }
}

pub(crate) fn python(value: i64) -> Option<Severity> {
    match value {
        10 => Some(Severity::Debug),
        20 => Some(Severity::Info),
        30 => Some(Severity::Warn),
        40 => Some(Severity::Error),
        50 => Some(Severity::Fatal),
        _ => None,
    }
}

pub(crate) fn otel(value: i64) -> Option<Severity> {
    match value {
        1..=4 => Some(Severity::Trace),
        5..=8 => Some(Severity::Debug),
        9..=12 => Some(Severity::Info),
        13..=16 => Some(Severity::Warn),
        17..=20 => Some(Severity::Error),
        21..=24 => Some(Severity::Fatal),
        _ => None,
    }
}