syslog-too 0.1.0

A small library to send log messages to syslog locally and over TCP or UDP using Rust. A continuation of the syslog crate.
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

//! Defines the RFC 5424 logger struct and trait implementations.

use super::{Logger, LoggerBackend};
use crate::Formatter3164;
use log::{Level, Log, Metadata, Record};
use std::io::Write;
use std::sync::{Arc, Mutex};

/// Logger struct for the RFC 3164 BSD syslog protocol.
pub struct Logger3164 {
    /// Create a new logger with the RFC5424 formatter.
    logger: Arc<Mutex<Logger<LoggerBackend, Formatter3164>>>,
}

impl Logger3164 {
    pub fn new(logger: Logger<LoggerBackend, Formatter3164>) -> Self {
        Self {
            logger: Arc::new(Mutex::new(logger)),
        }
    }
}

#[allow(unused_variables, unused_must_use)]
impl Log for Logger3164 {
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= log::max_level() && metadata.level() <= log::STATIC_MAX_LEVEL
    }

    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            //FIXME: temporary patch to compile
            let message = format!("{}", record.args());
            let mut logger = self.logger.lock().unwrap();
            match record.level() {
                Level::Error => logger.err(message),
                Level::Warn => logger.warning(message),
                Level::Info => logger.info(message),
                Level::Debug => logger.debug(message),
                Level::Trace => logger.debug(message),
            };
        }
    }

    fn flush(&self) {
        let _ = self.logger.lock().unwrap().backend.flush();
    }
}