flarelog 0.5.0

flarelog is an ergonomic logging library for Rust with a focus on simplicity and speed.
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

use crossbeam_channel;
use std::thread;
use std::io::BufWriter;
use std::io::prelude::*;
use std::fs::OpenOptions;
use crate::flare::{SerializedSender, SerializedReceiver};
use crate::mode::LogMode;
use std::sync::{Arc, Mutex};
use std::time::Duration;

const FLUSH_INTERVAL: Duration = Duration::from_millis(1000 * 30);

pub struct FlareIoWorker {
    pub thread_handle: thread::JoinHandle<()>,
    pub flush_thread_handle: thread::JoinHandle<()>,
    pub sender: SerializedSender,
}

impl FlareIoWorker {
    pub fn new(options: FlareIoOptions) -> Self {
        let file = OpenOptions::new().write(true).append(true).create(true).open(options.filename.clone()).unwrap();
        let writer = Arc::new(Mutex::new(BufWriter::with_capacity(options.bufwriter_cap, file)));

        let writer1 = writer.clone();

        let f_handle = thread::spawn(move || {
            loop {
                thread::sleep(FLUSH_INTERVAL);
                let mut w = writer1.lock().unwrap();
                w.flush().unwrap();
            }
        });

        let (s, r) = crossbeam_channel::unbounded();
        let interface = FlareIoWorkerInterface::new(r.clone());

        let handle = thread::spawn(move || {
            loop {
                let writer = writer.clone();
                let stringentry = interface.receiver.recv().unwrap();

                match options.mode {
                    LogMode::File => {
                        let mut w = writer.lock().unwrap();
                        let _ = w.write(stringentry.as_bytes());
                        let _ = w.write(&[b'\n']);
                    },
                    LogMode::TerminalAndFile => {
                        let mut w = writer.lock().unwrap();
                        let _ = w.write(stringentry.as_bytes());
                        let _ = w.write(&[b'\n']);
                        println!("{}", stringentry);
                    },
                }
            }
        });

        Self {
            thread_handle: handle,
            flush_thread_handle: f_handle,
            sender: s,
        }
    }
}

#[derive(Default)]
pub struct FlareIoOptions {
    pub mode: LogMode,
    pub filename: String,
    pub bufwriter_cap: usize,
}

impl FlareIoOptions {
    pub fn new() -> Self {
        Self {
            mode: LogMode::default(),
            bufwriter_cap: 0,
            filename: String::new(),
        }
    }

    pub fn mode(mut self, mode: LogMode) -> Self {
        self.mode = mode;
        self
    }

    pub fn bufwriter_cap(mut self, bufwriter_cap: usize) -> Self {
        self.bufwriter_cap = bufwriter_cap;
        self
    }

    pub fn filename(mut self, filename: String) -> Self {
        self.filename = filename;
        self
    }
}

#[derive(Clone)]
pub struct FlareIoWorkerInterface {
    pub receiver: SerializedReceiver,
}

impl FlareIoWorkerInterface {
    pub fn new(receiver: SerializedReceiver) -> Self {
        Self {
            receiver,
        }
    }
}