crilog 0.1.0

CRI logs parser
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

use chrono::DateTime;
use std::str::FromStr;

/// struct that represents a single log entry in CRI log format.
///  CRI Log format example:
///    2016-10-06T00:17:09.669794202Z stdout P log content 1
//     2016-10-06T00:17:09.669794203Z stderr F log content 2
//  See: https://github.com/kubernetes/kubernetes/blob/master/pkg/kubelet/kuberuntime/logs/logs.go#L128
pub struct CriLog {
    timestamp: DateTime<chrono::offset::FixedOffset>,
    stream_type: StreamType,
    tag: String,
    log: String,
}

impl CriLog {
    /// Get timestamp associated to log entry
    pub fn timestamp(&self) -> &DateTime<chrono::offset::FixedOffset> {
        &self.timestamp
    }

    /// Returns true if log entry is of type stderr
    pub fn is_stderr(&self) -> bool {
        self.stream_type == StreamType::StdErr
    }

    /// Returns true if log entry is of type stdout
    pub fn is_stdout(&self) -> bool {
        self.stream_type == StreamType::StdOut
    }

    /// Get tag attribute from log entry
    pub fn tag(&self) -> &str {
        &self.tag
    }

    /// Get message from log entry
    pub fn log(&self) -> &str {
        &self.log
    }
}

impl FromStr for CriLog {
    type Err = ParsingError;

    fn from_str(input: &str) -> Result<Self, <Self as FromStr>::Err> {
        let mut iter = input.split_whitespace();

        let timestamp_str = iter.next().ok_or(ParsingError::MissingTimestamp)?;
        let timestamp = DateTime::parse_from_rfc3339(timestamp_str)
            .map_err(|_| ParsingError::TimestampFormat(timestamp_str.into()))?;

        let stream_type_str = iter.next().ok_or(ParsingError::MissingStreamType)?;
        let stream_type = StreamType::from_str(stream_type_str)
            .map_err(|_| ParsingError::InvalidStreamType(stream_type_str.into()))?;

        let tag = iter.next().ok_or(ParsingError::MissingLogTag)?.to_owned();

        let log = iter.collect::<Vec<&str>>().join(" ");

        Ok(CriLog {
            timestamp,
            stream_type,
            tag,
            log,
        })
    }
}

#[derive(Debug, thiserror::Error)]
pub enum ParsingError {
    #[error("Missing timestamp in log entry")]
    MissingTimestamp,
    #[error("Timestamp format error: {0}")]
    TimestampFormat(String),
    #[error("Missing stream type")]
    MissingStreamType,
    #[error("Invalid stream type: {0}")]
    InvalidStreamType(String),
    #[error("Missing log tag")]
    MissingLogTag,
}

#[derive(Debug, PartialEq)]
pub enum StreamType {
    StdOut,
    StdErr,
}

impl FromStr for StreamType {
    type Err = InvalidStreamType;
    fn from_str(input: &str) -> Result<Self, <Self as FromStr>::Err> {
        match input {
            "stderr" => Ok(StreamType::StdErr),
            "stdout" => Ok(StreamType::StdOut),
            input => Err(InvalidStreamType(input.into())),
        }
    }
}

pub struct InvalidStreamType(String);

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn stdout() {
        //   2016-10-06T00:17:09.669794202Z stdout P log content 1
        //   2016-10-06T00:17:09.669794203Z stderr F log content 2
        let log_str = "2016-10-06T00:17:09.669794202Z stdout P log content 1";
        let crilog = CriLog::from_str(log_str).expect("failed to parse");
        assert!(crilog.is_stdout());
        assert_eq!(crilog.tag(), "P");
        assert_eq!(crilog.log(), "log content 1");
    }

    #[test]
    fn stderr() {
        let log_str = "2016-10-06T00:17:09.669794203Z stderr F log content 2";
        let crilog = CriLog::from_str(log_str).expect("failed to parse");
        assert!(crilog.is_stderr());
        assert_eq!(crilog.tag(), "F");
        assert_eq!(crilog.log(), "log content 2");
    }
}