compressed_log 0.5.6

Log compression on the fly
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

use crate::compression::Compression;
use crate::formatter::{default_formatter, Formatter};
use crate::logger::{Logger, TIMER};
use log::Level;
use std::cell::RefCell;
use std::fmt;
use std::io;
use std::time::Instant;

#[derive(Debug)]
pub enum LoggerError {
    ConnectionFailure(String),
    IoError(io::Error),
}

impl fmt::Display for LoggerError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            LoggerError::ConnectionFailure(e) => write!(f, "Actix Connection Failure {:?}", e),
            LoggerError::IoError(e) => write!(f, "IoError {:?}", e),
        }
    }
}

impl From<io::Error> for LoggerError {
    fn from(error: io::Error) -> Self {
        LoggerError::IoError(error)
    }
}

pub struct LoggerBuilder {
    level: Level,
    compression: Compression,
    sink_url: String,
    threshold: usize,
    format: RefCell<Box<Formatter>>,
    store_tmp_logs: bool,
}

impl Default for LoggerBuilder {
    fn default() -> LoggerBuilder {
        LoggerBuilder {
            /// Log all messages by default
            level: Level::Trace,
            /// Default is supposed to be low to provide fast on the fly compression
            compression: Compression::Suggested,
            /// Setting to localhost by default
            sink_url: "http://127.0.0.1:9999/compressed_sink".to_string(),
            /// Default threshold is about 1MB of uncompressed data
            /// this should be much larger but sometimes we operate
            /// on very memory constrained machines
            threshold: 1_000_000usize,
            /// Default format for backwards compatibility
            format: RefCell::new(Box::new(default_formatter)),
            /// by default don't waste memory on a log buffer
            store_tmp_logs: false,
        }
    }
}

impl LoggerBuilder {
    pub fn set_level(mut self, level: Level) -> Self {
        self.level = level;
        self
    }
    /// Sets compression level
    pub fn set_compression_level(mut self, compression: Compression) -> Self {
        self.compression = compression;
        self
    }
    pub fn set_sink_url(mut self, url: &str) -> Self {
        self.sink_url = url.to_string();
        self
    }
    pub fn set_format(mut self, format: Box<Formatter>) -> Self {
        self.format = RefCell::new(format);
        self
    }
    pub fn set_buffer_size(mut self, buffer_size: usize) -> Self {
        self.threshold = buffer_size;
        self
    }
    /// Enables the storage of a log buffer in /tmp/ for debugging
    pub fn enable_tmp_log_storage(mut self) -> Self {
        self.store_tmp_logs = true;
        self
    }
    pub fn build(&self) -> Result<Logger, LoggerError> {
        debug_eprintln!("Building compressed logger");
        let sink_url = self.sink_url.clone();

        // Extract inner formatter by swapping it
        let formatter = self.format.replace(Box::new(default_formatter));

        //Start the timer
        *TIMER.write().unwrap() = Instant::now();

        Logger::with_level(
            self.level,
            self.compression,
            self.threshold,
            sink_url,
            formatter,
            self.store_tmp_logs,
        )
    }
}