logger2 0.1.5

A modern, feature-rich replacement for the classic `logger` CLI: syslog (local/remote, RFC3164 & RFC5424), truecolor hex output, emoji, JSON, and a fully configurable TOML config file.
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

use crate::error::{Logger2Error, Result};
use std::io::Write;
use std::net::{TcpStream, UdpSocket};
use std::path::Path;
use std::time::Duration;

/// Sends a fully-formatted syslog line to the local system logger via its
/// Unix domain socket (e.g. `/dev/log` on Linux, `/var/run/syslog` on macOS).
#[cfg(unix)]
pub fn send_local(socket_path: &Path, message: &str) -> Result<()> {
    use std::os::unix::net::UnixDatagram;

    let sock = UnixDatagram::unbound()?;
    // Most syslog daemons expect a datagram; some (notably older syslog-ng
    // configs) expect a stream socket. Try datagram first, then fall back.
    match sock.connect(socket_path) {
        Ok(()) => {
            sock.send(message.as_bytes())
                .map_err(|e| Logger2Error::Network(socket_path.display().to_string(), e))?;
            Ok(())
        }
        Err(_) => {
            use std::os::unix::net::UnixStream;
            let mut stream = UnixStream::connect(socket_path)
                .map_err(|e| Logger2Error::Network(socket_path.display().to_string(), e))?;
            stream
                .write_all(message.as_bytes())
                .map_err(|e| Logger2Error::Network(socket_path.display().to_string(), e))?;
            Ok(())
        }
    }
}

#[cfg(not(unix))]
pub fn send_local(_socket_path: &Path, _message: &str) -> Result<()> {
    Err(Logger2Error::UnsupportedPlatform(
        "local unix-socket syslog is only available on unix-like systems; use --server to log to a remote syslog daemon instead".to_string(),
    ))
}

/// Sends a message to a remote syslog daemon over UDP.
pub fn send_udp(server: &str, port: u16, message: &str) -> Result<()> {
    let sock = UdpSocket::bind("0.0.0.0:0")
        .map_err(|e| Logger2Error::Network(format!("{server}:{port}"), e))?;
    sock.connect((server, port))
        .map_err(|e| Logger2Error::Network(format!("{server}:{port}"), e))?;
    sock.send(message.as_bytes())
        .map_err(|e| Logger2Error::Network(format!("{server}:{port}"), e))?;
    Ok(())
}

/// Sends a message to a remote syslog daemon over TCP, with an optional
/// connect timeout.
pub fn send_tcp(server: &str, port: u16, message: &str, timeout: Duration) -> Result<()> {
    use std::net::ToSocketAddrs;

    let addr = format!("{server}:{port}")
        .to_socket_addrs()
        .map_err(|e| Logger2Error::Network(format!("{server}:{port}"), e))?
        .next()
        .ok_or_else(|| {
            Logger2Error::Network(
                format!("{server}:{port}"),
                std::io::Error::new(std::io::ErrorKind::NotFound, "no address resolved"),
            )
        })?;

    let mut stream = TcpStream::connect_timeout(&addr, timeout)
        .map_err(|e| Logger2Error::Network(format!("{server}:{port}"), e))?;
    stream
        .write_all(message.as_bytes())
        .map_err(|e| Logger2Error::Network(format!("{server}:{port}"), e))?;
    Ok(())
}