ticklog 0.1.0

A fast, minimal logging library for Rust, designed for performance-critical applications, e.g. high-frequency trading.
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
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

use std::fmt;

/// The severity of a log message, ordered from most severe
/// ([`Error`](Level::Error)) to least severe ([`Trace`](Level::Trace)).
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[repr(u8)]
pub enum Level {
    /// A serious failure.
    Error = 1,
    /// A recoverable problem or unexpected condition.
    Warn = 2,
    /// A normal, noteworthy event.
    Info = 3,
    /// Detailed information useful while debugging.
    Debug = 4,
    /// Very fine-grained tracing.
    Trace = 5,
}

impl Level {
    /// Returns the static string representation of this level.
    ///
    /// ```
    /// assert_eq!(ticklog::Level::Error.as_str(), "ERROR");
    /// assert_eq!(ticklog::Level::Info.as_str(), "INFO");
    /// ```
    #[inline]
    pub fn as_str(self) -> &'static str {
        match self {
            Level::Error => "ERROR",
            Level::Warn => "WARN",
            Level::Info => "INFO",
            Level::Debug => "DEBUG",
            Level::Trace => "TRACE",
        }
    }

    /// Returns the `u8` discriminant of this level.
    #[inline]
    pub(crate) fn to_u8(self) -> u8 {
        self as u8
    }

    /// Convert from a `u8` value. Returns `None` for values outside `1..=5`.
    #[inline]
    pub(crate) fn from_u8(b: u8) -> Option<Level> {
        match b {
            1 => Some(Level::Error),
            2 => Some(Level::Warn),
            3 => Some(Level::Info),
            4 => Some(Level::Debug),
            5 => Some(Level::Trace),
            _ => None,
        }
    }
}

impl fmt::Display for Level {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

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

    #[test]
    fn discriminants() {
        assert_eq!(Level::Error as u8, 1);
        assert_eq!(Level::Warn as u8, 2);
        assert_eq!(Level::Info as u8, 3);
        assert_eq!(Level::Debug as u8, 4);
        assert_eq!(Level::Trace as u8, 5);
    }

    #[test]
    fn ordering() {
        assert!(Level::Error < Level::Warn);
        assert!(Level::Warn < Level::Info);
        assert!(Level::Info < Level::Debug);
        assert!(Level::Debug < Level::Trace);
    }

    #[test]
    fn as_str_uppercase() {
        assert_eq!(Level::Error.as_str(), "ERROR");
        assert_eq!(Level::Warn.as_str(), "WARN");
        assert_eq!(Level::Info.as_str(), "INFO");
        assert_eq!(Level::Debug.as_str(), "DEBUG");
        assert_eq!(Level::Trace.as_str(), "TRACE");
    }

    #[test]
    fn display_matches_as_str() {
        assert_eq!(Level::Error.to_string(), "ERROR");
        assert_eq!(Level::Warn.to_string(), "WARN");
        assert_eq!(Level::Info.to_string(), "INFO");
        assert_eq!(Level::Debug.to_string(), "DEBUG");
        assert_eq!(Level::Trace.to_string(), "TRACE");
    }

    #[test]
    fn u8_roundtrip() {
        for level in [
            Level::Error,
            Level::Warn,
            Level::Info,
            Level::Debug,
            Level::Trace,
        ] {
            assert_eq!(Level::from_u8(level.to_u8()), Some(level));
        }
    }

    #[test]
    fn to_u8_is_discriminant() {
        assert_eq!(Level::Error.to_u8(), 1);
        assert_eq!(Level::Warn.to_u8(), 2);
        assert_eq!(Level::Info.to_u8(), 3);
        assert_eq!(Level::Debug.to_u8(), 4);
        assert_eq!(Level::Trace.to_u8(), 5);
    }

    #[test]
    fn from_u8_rejects_invalid() {
        assert_eq!(Level::from_u8(0), None);
        assert_eq!(Level::from_u8(6), None);
        assert_eq!(Level::from_u8(255), None);
    }
}