syslog-rs 6.6.1

A native Rust implementation of the glibc/libc/windows syslog client and windows native log for logging.
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

#![cfg(all(target_family = "windows", feature = "build_with_thread_local"))]
extern crate syslog_rs;

use std::{cell::RefCell, time::Instant};

use syslog_rs::{LogFacility, LogStat, Priority, SyStreamPriDebug, WindowsEvent, sync::syslog_threadlocal::SingleSyslog};

#[test]
fn test_thread_signalling()
{
    thread_local! 
    {
        // Could add pub to make it public to whatever Foo already is public to.
        static SYSLOG: RefCell<SingleSyslog> = 
            RefCell::new(SingleSyslog::openlog_with(Some("test"), LogStat::LOG_PID , 
                LogFacility::LOG_DAEMON, WindowsEvent::new()).unwrap());
    }

    let thread = 
        std::thread::spawn(move ||
            {
                for i in 0..10
                {
                    let fmms = format!("test message {} from thread {:?}", i, std::thread::current().name());
                    let s = Instant::now();

                    SYSLOG
                        .with_borrow_mut(|syslog| 
                            syslog
                                .syslog(
                                    Priority::LOG_ERR, 
                                    fmms.into()
                                )
                                .unwrap()
                        );

                    let e = s.elapsed();

                    println!("{:?}", e);
                }
            }
        );


    SYSLOG
        .with_borrow_mut(|syslog| 
            syslog
                .syslog(
                    Priority::LOG_DEBUG, 
                    format!("main test message from thread {:?}", std::thread::current().name()).into()
                )
                .unwrap()
        );


    thread.join().unwrap();

    return;

}

#[test]
fn test_single_stream_test()
{
    use std::fmt::Write;

    let log = 
            SingleSyslog::openlog(
                Some("test1"), 
                LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, 
                LogFacility::LOG_DAEMON,
            WindowsEvent::new());

    assert_eq!(log.is_ok(), true, "{}", log.err().unwrap());

    let mut log = log.unwrap();
    
    write!(log.get_stream::<SyStreamPriDebug>(), "test stream singlesyslog").unwrap();

    for i in 0..3
    {
        let s = Instant::now();
        write!(log.get_stream::<SyStreamPriDebug>(), "test stream singlesyslog {}", i).unwrap();
        let e = s.elapsed();

        println!("{:?}", e);
    }

}