hclog 0.1.0

A high configurable logging library for Rust
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
132
133
134
135
136
137
138
139
140
141
142

use crate::{level::Level, logmod::ScopeEnv, options::*};
use chrono::{DateTime, Utc};
use std::{
    fmt::{self, Display, Debug, Arguments},
    borrow::Cow,
    process,
    thread,
};

#[derive(Debug)]
pub struct Message<'a> {
    options: &'a Options,
    time: DateTime<Utc>,
    binname: &'a str,
    severity: Option<&'a Level>,
    modname: Option<Cow<'a, str>>,
    scope: Option<&'a ScopeEnv>,
    scope_ident: Option<&'a str>,
    file: &'a str,
    func: &'a str,
    line: u32,
    fmt: Cow<'a, str>,
}
/*
 * NOTE: fmt::Display is always buffered and options.line_buffered = false is not implemented.
 * To implement we would need to use std::io::Write and a custom (or different) formatter."
 */
impl<'a> Display for Message<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.options.has(DATESTAMP) {
            write!(f, "{} ", self.time.format("%F"))?;
        }
        if self.options.has(TIMESTAMP) {
            match self.options.has(NANOSEC) {
                true => write!(f, "{} ", self.time.format("%X.%f"))?,
                false => write!(f, "{} ", self.time.format("%X"))?,
            };
        }
        if self.options.has(BINNAME) {
            write!(f, "{}", self.binname)?;
        }
        if self.options.has(PID) {
            if self.options.has(TID) {
                write!(f, "[{}/{}] ", process::id(), Self::get_current_thread_id())?;
            } else {
                write!(f, "[{}] ", process::id())?;
            }
        } else if self.options.has(TID) {
            write!(f, "[{}] ", Self::get_current_thread_id())?;
        } else if self.options.has(BINNAME) {
                write!(f, " ")?;
        }

        if let Some(s) = self.severity {
            write!(f, "{} ", s)?;
        }
        if let Some(ref m) = self.modname {
            write!(f, "{} ", m)?;
        }
        if let Some(s) = self.scope {
            if let Some(ref i) = self.scope_ident {
                write!(f, "{}[{}] ", s, i)?;
            } else {
                write!(f, "{} ", s)?;
            }
        }
        // file=false implicitly also disables line
        if self.options.has(FILE) {
            if self.options.has(LINE) {
                write!(f, "{}:{} ", self.file, self.line)?;
            } else {
                write!(f, "{} ", self.file)?;
            }
        }
        if self.options.has(FUNC) {
            if !self.func.is_empty() {
                write!(f, "{} ", self.func)?;
            }
        }

        write!(f, "{}", self.fmt)
    }
}
impl<'a> Message<'a> {
    pub (crate) fn new(
        options: &'a Options, binname: &'a str, file: &'a str, func: &'a str,
        line: u32, fmt: &'a Arguments,
    ) -> Self {
        let fmt = match fmt.as_str() {
            Some(s) => Cow::Borrowed(s),
            None => Cow::Owned(fmt.to_string()),
        };
        Self {
            options,
            time: Utc::now(),
            binname,
            severity: None,
            modname: None,
            scope: None,
            scope_ident: None,
            file,
            func,
            line,
            fmt,
        }
    }
    // those fields are set by the module (if set in config)
    pub (crate) fn set_severity(&mut self, lvl: &'a Level) -> &mut Self {
        if self.options.has(SEVERITY) {
            self.severity = Some(lvl);
        }
        self
    }
    pub (crate) fn set_modname(&mut self, name: &'a str) -> &mut Self {
        if self.options.has(MODULE) {
            self.modname = Some(Cow::Borrowed(name));
        }
        self
    }
    pub (crate) fn set_scope(&mut self, scope: &'a ScopeEnv, ident: Option<&'a str>) -> &mut Self {
        if self.options.has(SCOPE) {
            self.scope = Some(scope);
            self.scope_ident = ident;
        }
        self
    }

    /*
     * ThreadId has no display, to_str or to_u64 method. Since str::parse would
     * fail if we not strip the ThreadId() part from the debug output we have to
     * remove this beforehand
     * Will be obsolete once https://github.com/rust-lang/rust/issues/67939 is
     * stable and available in our rust version
     */
    fn get_current_thread_id() -> u64 {
        let tid = format!("{:?}", thread::current().id());
        let tid = tid.strip_prefix("ThreadId(").unwrap_or(&tid);
        let tid = tid.strip_suffix(")").unwrap_or(tid);
        tid.parse::<u64>().unwrap()
    }
}