syslog-rs 6.5.0

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
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

/*-
 * syslog-rs - a syslog client translated from libc to rust
 * 
 * Copyright 2025 Aleksandr Morozov
 * 
 * The syslog-rs crate can be redistributed and/or modified
 * under the terms of either of the following licenses:
 *
 *   1. the Mozilla Public License Version 2.0 (the “MPL”) OR
 *
 *   2. The MIT License (MIT)
 *                     
 *   3. EUROPEAN UNION PUBLIC LICENCE v. 1.2 EUPL © the European Union 2007, 2016
 */

use std::{fmt, time::Duration};

use crate::
{
    error::SyRes, 
    formatters::SyslogFormatter, 
    map_error_code, 
    sy_sync_queue::
    {
        SyCmd, 
        SyslogQueueChanRcv, 
        SyslogQueueChanSnd, 
        SyslogQueueChannel, 
        SyslogQueueOneChanRcv, 
        SyslogQueueOneChanSnd
    }, 
    SyslogDestination
};

use crossbeam_channel::{bounded, unbounded};

// -- implemetations for the crossbeam channels -- 

impl<F: SyslogFormatter, D: SyslogDestination, S: SyslogQueueChannel<F, D>> SyslogQueueChanRcv<F, D, S> 
for crossbeam_channel::Receiver<SyCmd<F, D, S>>
{
    fn q_recv_blocking(&mut self) -> Option<SyCmd<F, D, S>>
    {
        return 
            self
                .recv_timeout(Duration::from_millis(100))
                .ok();
    }
}

impl<F: SyslogFormatter, D: SyslogDestination, S: SyslogQueueChannel<F, D>> SyslogQueueChanSnd<F, D, S> 
for crossbeam_channel::Sender<SyCmd<F, D, S>>
{
    fn q_send_blocking(&self, msg: SyCmd<F, D, S>) -> SyRes<()> 
    {
        return 
            self
                .send_timeout(msg, Duration::from_millis(100))
                .map_err(|e| 
                    map_error_code!(SendError, "send_blocking() error: '{}'", e)

                );
    }
}

impl<C: Send> SyslogQueueOneChanSnd<C> for crossbeam_channel::Sender<C>
{
    fn send_once_blocking(self, data: C) -> Result<(), C>
    {
        return 
            self
                .send_timeout(data, Duration::from_millis(100))
                .map_err(|e| e.into_inner());
    }
}

impl<C> SyslogQueueOneChanRcv<C> for crossbeam_channel::Receiver<C>
{
    fn recv_once_blocking(self) -> SyRes<C> 
    {
        return 
            self
                .recv_timeout(Duration::from_millis(500))
                .map_err(|e|
                    map_error_code!(UnboundedChannelError, "channel error: '{}'", e)

                );
    }
}


// --- impls ends ---

/// A queue provider based on the Crossbeam mpsc.
#[derive(Debug, Clone)]
pub struct CrossbeamQueueAdapter;

unsafe impl Send for CrossbeamQueueAdapter {}

impl<F: SyslogFormatter, D: SyslogDestination> SyslogQueueChannel<F, D> for CrossbeamQueueAdapter
{
    const ADAPTER_NAME: &'static str = "crossbeam";
    
    type ChannelSnd = crossbeam_channel::Sender<SyCmd<F, D, Self>>;

    type ChannelRcv = crossbeam_channel::Receiver<SyCmd<F, D, Self>>;

    type OneShotChannelSnd<C: Send + fmt::Debug> = crossbeam_channel::Sender<C>;

    type OneShotChannelRcv<C> = crossbeam_channel::Receiver<C>;

    fn create_channel() -> (Self::ChannelSnd, Self::ChannelRcv) 
    {
        return unbounded::<SyCmd<F, D, Self>>();
    }

    fn create_oneshot_channel<C: Send + fmt::Debug>() -> (Self::OneShotChannelSnd<C>, Self::OneShotChannelRcv<C>) 
    {
        return bounded::<C>(1);
    }
}

pub type DefaultQueueAdapter = CrossbeamQueueAdapter;