syslog_rs/

logger.rs

/*-
 * 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::{borrow::Cow, env::{self, VarError}, str::FromStr};

#[cfg(feature = "build_sync")]
use crate::{LogFacility, LogStat, Priority, };
#[cfg(feature = "build_ext_file")]
use crate::SyslogFile;
#[cfg(feature = "build_ext_tls")]
use crate::SyslogTls;
#[cfg(feature = "build_ext_net")]
use crate::{SyslogNetTcp, SyslogNetUdp};
#[cfg(feature = "build_with_queue")]
use crate::{SyQueued, sy_sync_queue::SyslogQueueChannel};
#[cfg(feature = "build_with_thread_local")]
use crate::{MutDynSyslog, SyThreadLocal};

use crate::{
    DynSyslog, LOG_UPTO, SyShared, Syslog, SyslogDestination, SyslogLocal, 
    error::{SyRes}, 
    formatters::
    {
        DEFAULT_SYSLOG_FORMATTER_TYPE, FormatFile, FormatRfc3146, FormatRfc5424, SyslogFormatter, 
        SyslogFormatters
    }, 
    map_error, throw_error
};


/// * `local#` - for default
/// * `local#/var/run/syslogcustom` - for custom path 
pub const LOGGER_TYPE_LOCAL: &'static str = "local";

/// * `udp#127.0.0.1:80` - for IPv4 + port
/// * `udp#[fe00:::0]:80` - for IPv6 + port
/// * `udp#www.mydomain.tdl:80` - for hostname + port
pub const LOGGER_TYPE_UDP: &'static str = "udp";

/// * `tcp#127.0.0.1:80` - for IPv4 + port
/// * `tcp#[fe00:::0]:80` - for IPv6 + port
/// * `tcp#www.mydomain.tdl:80` - for hostname + port
pub const LOGGER_TYPE_TCP: &'static str = "tcp";

/// * `tls#127.0.0.1:80#servername#root_cert_path` - for IPv4 + port
/// * `tls#[fe00:::0]:80#servername#root_cert_path` - for IPv6 + port
/// * `tls#www.mydomain.tdl:80#servername#root_cert_path` - for hostname + port
pub const LOGGER_TYPE_TLS: &'static str = "tls";

/// * `file#/tmp/file1.txt` - for file append mode
pub const LOGGER_TYPE_FILE: &'static str = "file";

/// A syslog server destinatio: type and location. If not set, then logging is disabled.
pub const SYSLOG_LOGGER_DST_URI: &'static str = "SYSLOG_LOGGER_DST_URI";

/// A log facility. Starts with "LOG_*" see [LogFacility]. If not set, then default.
pub const SYSLOG_LOGGER_LOG_FACILITY: &'static str = "SYSLOG_LOGGER_LOG_FACILITY";

/// A formatter. See `formatters` for available. It is defined as `FORMATTER_NAME`.
/// 
/// If not defined, then a default formatter will be used.
/// 
/// Available: RFC3146, RFC5424, FILE.
pub const SYSLOG_LOGGER_LOG_FORMATTER: &'static str = "SYSLOG_LOGGER_LOG_FORMATTER";

/// An identification of the program. If not set, will be determined automatically.
/// 
/// If used in crate, then don't set this.
pub const SYSLOG_LOGGER_LOG_IDENTITY: &'static str = "SYSLOG_LOGGER_LOG_IDENTITY";

/// Limits the message to upto `logmask`. Same as in libc's syslog.
/// 
/// LOG_UPTO!(Priority::LOG_ERROR) see [Priority].
pub const SYSLOG_LOGGER_LOG_UPTO: &'static str = "SYSLOG_LOGGER_LOG_UPTO";

#[cfg(not(feature = "logger_lazy"))]
mod logger_cells
{
    #[cfg(feature = "build_with_thread_local")]
    use std::cell::RefCell;
    use std::sync::OnceLock;

    use crate::DynSyslog;
    #[cfg(feature = "build_with_thread_local")]
    use crate::MutDynSyslog;

    /// A logger instances. todo: if one instance fails, use backup.
    pub(crate) static LOGGER: OnceLock<Box<dyn DynSyslog + Send + Sync>> = OnceLock::new();

    #[cfg(feature = "build_with_thread_local")]
    thread_local! 
    {
        // A thread local logger
        pub(super) static LOGGER_LOCAL: RefCell<Option<Box<dyn MutDynSyslog>>> = RefCell::new(None);
    }
}

/// In lazy init, it is not required to call an init_*. It will be initialized
/// automatically on the first access.
#[cfg(feature = "logger_lazy")]
mod logger_lazy
{
    use std::sync::LazyLock;

    use crate::{DynSyslog, SyShared, logger::internal_init_event_log};

    pub(crate) static LOGGER: LazyLock<Option<Box<dyn DynSyslog + Send + Sync>>> = 
        LazyLock::new(
            ||
            {
                match internal_init_event_log::<SyShared>(None)
                {
                    Ok(sy) => sy,
                    Err(e) => 
                    {
                        if cfg!(feature = "logger_lazy_silence_panic")
                        {
                            None
                        }
                        else
                        {
                            panic!("{}", e);
                        }
                    }
                }
            }
        );
}

fn derive_suffix(suffix: Option<&str>, env_name: &'static str) -> Cow<'static, str>
{
    if let Some(su) = suffix
    {
        Cow::Owned([env_name, "_", su].concat())
    }
    else
    {
        Cow::Borrowed(env_name)
    }
}

#[derive(Debug)]
struct EnvVars
{
    logger_type_res: String,
    logger_facility: LogFacility,
    logger_formatter: SyslogFormatters,
    logger_identity: Option<String>,
    logger_upto: Option<Priority>,
}

impl EnvVars
{
    fn read_env(env_sufix: Option<&str>) -> SyRes<Option<Self>>
    {
        let logger_type_res = 
            match env::var(derive_suffix(env_sufix, SYSLOG_LOGGER_DST_URI).as_ref())
            {
                Ok(val) => 
                    val,
                Err(VarError::NotPresent) => 
                    return Ok(None),
                Err(VarError::NotUnicode(_e)) =>
                    throw_error!("{} is not unicode", SYSLOG_LOGGER_DST_URI)
            };

        let logger_facility= 
            match env::var(derive_suffix(env_sufix, SYSLOG_LOGGER_LOG_FACILITY).as_ref())
            {
                Ok(val) => 
                    LogFacility::from_str(&val)?,
                Err(VarError::NotPresent) => 
                    LogFacility::LOG_DAEMON,
                Err(VarError::NotUnicode(_e)) =>
                    throw_error!("{} is not unicode", SYSLOG_LOGGER_LOG_FACILITY)
            };

        let logger_formatter = 
            match env::var(derive_suffix(env_sufix, SYSLOG_LOGGER_LOG_FORMATTER).as_ref())
            {
                Ok(val) => 
                    SyslogFormatters::from_str(&val)?,
                Err(VarError::NotPresent) => 
                    DEFAULT_SYSLOG_FORMATTER_TYPE,
                Err(VarError::NotUnicode(_e)) =>
                    throw_error!("{} is not unicode", SYSLOG_LOGGER_LOG_FORMATTER)
            };

        let logger_identity = 
            match env::var(derive_suffix(env_sufix, SYSLOG_LOGGER_LOG_IDENTITY).as_ref())
            {
                Ok(val) => 
                    Some(val),
                Err(VarError::NotPresent) => 
                    None,
                Err(VarError::NotUnicode(_e)) =>
                    throw_error!("{} is not unicode", SYSLOG_LOGGER_LOG_IDENTITY)
            };

            
        let logger_upto = 
            match env::var(derive_suffix(env_sufix, SYSLOG_LOGGER_LOG_UPTO).as_ref())
            {
                Ok(val) => 
                    Some(Priority::from_str(&val)?),
                Err(VarError::NotPresent) => 
                    None,
                Err(VarError::NotUnicode(_e)) =>
                    throw_error!("{} is not unicode", SYSLOG_LOGGER_LOG_IDENTITY)
            };

        return Ok(
            Some(
                Self
                {
                    logger_type_res, logger_facility, logger_formatter, logger_identity, logger_upto
                }
            )
        );
    }
}

#[derive(Debug, PartialEq, Eq)]
enum LoggerDst<'a>
{
    LoLocal{ dst_path: Option<&'a str> },
    
    #[cfg(feature = "build_ext_net")]
    LoUdp{ dst_host: &'a str },

    #[cfg(feature = "build_ext_net")]
    LoTcp{ dst_host: &'a str },

    #[cfg(feature = "build_ext_tls")]
    LoTls
    {
        dst_host: &'a str,
        serv_name: &'a str, 
        root_cert_path: &'a str,
    },

    #[cfg(feature = "build_ext_file")]
    LoFile{ dst_path: &'a str }
}

impl<'a> LoggerDst<'a>
{
    fn from_str(lo_sch: &'a str) -> SyRes<Self>
    {
        let (dst_type, payload) = 
            lo_sch
                .split_once("#")
                .ok_or_else(||
                    map_error!("{} incorrect format, expected type#dst:extras", SYSLOG_LOGGER_DST_URI)
                )?;

        let res = 
            match dst_type.to_lowercase().as_str()
            {
                LOGGER_TYPE_LOCAL =>
                {
                    let dst_path = payload.trim();

                    if dst_path.is_empty() == false
                    {
                        Self::LoLocal{ dst_path: Some(dst_path) }
                    }
                    else
                    {
                        Self::LoLocal{ dst_path: None }
                    }
                },

                #[cfg(feature = "build_ext_net")]
                LOGGER_TYPE_UDP => 
                {
                    let dst_host = payload.trim();
                    
                    Self::LoUdp{ dst_host }
                },

                #[cfg(not(feature = "build_ext_net"))]
                LOGGER_TYPE_UDP => 
                    throw_error!("cannot use UDP, crate compiled without `build_ext_net`!"),

                #[cfg(feature = "build_ext_net")]
                LOGGER_TYPE_TCP => //SyslogNetTcp
                {
                    let dst_host = payload.trim();

                    Self::LoTcp{ dst_host }
                },

                #[cfg(not(feature = "build_ext_net"))]
                LOGGER_TYPE_TCP => 
                    throw_error!("cannot use UDP, crate compiled without `build_ext_net`!"),
                
                #[cfg(feature = "build_ext_tls")]
                LOGGER_TYPE_TLS => 
                {
                    let (dst_host, payload) = 
                        payload
                            .split_once("#")
                            .map(|c| (c.0.trim(), c.1))
                            .ok_or_else(||
                                map_error!("SYSLOG_LOGGER_DST_URI incorrect format, expected type#dst:extras")
                            )?;

                    let (serv_name, root_cert_path) = 
                        payload
                            .split_once("#")
                            .map(|c| (c.0.trim(), c.1))
                            .ok_or_else(||
                                map_error!("SYSLOG_LOGGER_DST_URI incorrect format, expected type#dst:extras")
                            )?;

                    Self::LoTls{ dst_host, serv_name, root_cert_path }
                },

                #[cfg(not(feature = "build_ext_tls"))]
                LOGGER_TYPE_TLS => 
                    throw_error!("cannot use UDP, crate compiled without `build_ext_tls`!"),

                #[cfg(feature = "build_ext_file")]
                LOGGER_TYPE_FILE => 
                {
                    let dst_path = payload.trim();

                    Self::LoFile{ dst_path }
                },

                #[cfg(not(feature = "build_ext_file"))]
                LOGGER_TYPE_FILE =>
                    throw_error!("cannot use UDP, crate compiled without `build_ext_file`!"),

                n => 
                    throw_error!("SYSLOG_LOGGER_DST_URI unknown syslog dest type: {}", n)
            };

        return Ok(res);
    }
}


trait LoggerDynRet
{
    type RetType;

    fn openlog_with<F, D>(ident: Option<String>, logstat: LogStat, facility: LogFacility, net_tap_prov: D) -> SyRes<Self::RetType>
    where
        F: SyslogFormatter,
        D: SyslogDestination;

    fn set_prio(syslog_inst: &mut Self::RetType, opt_prio: Option<Priority>) -> SyRes<()>;
}

impl LoggerDynRet for SyShared
{
    type RetType = Box<dyn DynSyslog + Send + Sync>;

    fn openlog_with<F, D>(ident: Option<String>, logstat: LogStat, facility: LogFacility, net_tap_prov: D) -> SyRes<Self::RetType>
    where
        F: SyslogFormatter,
        D: SyslogDestination,
    {
        Syslog
            ::<F, D, Self>
            ::openlog_with(ident.as_ref().map(|d| d.as_str()), 
                logstat, facility, net_tap_prov)
                    .map(|sy| sy.make_dyn())
    }

    fn set_prio(syslog_inst: &mut Self::RetType, opt_prio: Option<Priority>) -> SyRes<()>
    {
        if let Some(prio) = opt_prio
        {
            syslog_inst.setlogmask(LOG_UPTO!(prio))?;
        }

        return Ok(());
    }
}

#[cfg(feature = "build_with_thread_local")]
impl LoggerDynRet for SyThreadLocal
{
    type RetType = Box<dyn MutDynSyslog>;

    fn openlog_with<F, D>(ident: Option<String>, logstat: LogStat, facility: LogFacility, net_tap_prov: D) -> SyRes<Self::RetType>
    where
        F: SyslogFormatter,
        D: SyslogDestination,
    {
        Syslog
            ::<F, D, Self>
            ::openlog_with(ident.as_ref().map(|d| d.as_str()), 
                logstat, facility, net_tap_prov)
                    .map(|sy| sy.make_dyn())
    }

    fn set_prio(syslog_inst: &mut Self::RetType, opt_prio: Option<Priority>) -> SyRes<()>
    {
        if let Some(prio) = opt_prio
        {
            syslog_inst.setlogmask(LOG_UPTO!(prio))?;
        }

        return Ok(());
    }
}

/// Initialzes the logger of type [SyShared] from the environment variables. 
/// If variables are not configured, exists without error. Should be called only once. 
/// 
/// The behaviour after `fork()` was not tested. So, it is advised to reconnect because the
/// FD will become invalid.
/// 
/// # Arguments
/// 
/// * `env_suffix` - specifies a specific suffix of environment variables. For example,
///     `SYSLOG_LOGGER_DST_URI` with suffix set to `XIO`, an `env` will be 
///     searched as `SYSLOG_LOGGER_DST_URI_XIO`.
/// 
/// # Returns
/// 
/// An error is returned if:
/// 
/// * called twice (re-initialization)
/// 
/// * if parsing of the env variables failes due to incorrect structure or whatever
/// 
/// * syslog client fails to establish connection (at the moment silencing this error is
///     not supported)
/// 
/// # Examples:
/// 
/// Setting the env to:
/// ```text
/// SYSLOG_LOGGER_DST_URI="local#"
/// SYSLOG_LOGGER_LOG_FACILITY="LOG_DAEMON"
/// SYSLOG_LOGGER_LOG_FORMATTER="RFC3146"
/// SYSLOG_LOGGER_LOG_IDENTITY="new_identity"
/// ```
/// 
/// should be initialized with:
/// 
/// ```ignore
/// init_event_log(None).unwrap();
/// ```
/// -- OR --
/// 
/// Setting the env to:
/// ```text
/// SYSLOG_LOGGER_DST_URI_XIO="local#"
/// SYSLOG_LOGGER_LOG_FACILITY_XIO="LOG_DAEMON"
/// SYSLOG_LOGGER_LOG_FORMATTER_XIO="RFC3146"
/// SYSLOG_LOGGER_LOG_IDENTITY_XIO="xio0"
/// ```
/// 
/// should be initialized with:
/// 
/// ```ignore
/// init_event_log(Some("XIO")).unwrap();
/// ```
#[cfg(all(not(feature = "logger_lazy")))]
pub 
fn init_event_log(env_suffix: Option<&str>) -> SyRes<()>
{
    let Some(syslog) = internal_init_event_log::<SyShared>(env_suffix)?
        else { return Ok(()) };

    logger_cells::LOGGER.set(syslog).map_err(|_e| map_error!("duplicate call to init_event_log()"))?;

    return Ok(());
}

/// Initialzes the logger of type [SyThreadLocal] from the environment variables. 
/// If variables are not configured, exists without error. Should be called only once. 
/// 
/// The behaviour after `fork()` was not tested. So, it is advised to reconnect because the
/// FD will become invalid.
/// 
/// # Arguments
/// 
/// * `env_suffix` - specifies a specific suffix of environment variables. For example,
///     `SYSLOG_LOGGER_DST_URI` with suffix set to `XIO`, an `env` will be 
///     searched as `SYSLOG_LOGGER_DST_URI_XIO`.
/// 
/// # Returns
/// 
/// An error is returned if:
/// 
/// * called twice (re-initialization)
/// 
/// * if parsing of the env variables failes due to incorrect structure or whatever
/// 
/// * syslog client fails to establish connection (at the moment silencing this error is
///     not supported)
/// 
/// # Examples:
/// 
/// Setting the env to:
/// ```text
/// SYSLOG_LOGGER_DST_URI="local#"
/// SYSLOG_LOGGER_LOG_FACILITY="LOG_DAEMON"
/// SYSLOG_LOGGER_LOG_FORMATTER="RFC3146"
/// SYSLOG_LOGGER_LOG_IDENTITY="new_identity"
/// ```
/// 
/// should be initialized with:
/// 
/// ```ignore
/// init_event_log(None).unwrap();
/// ```
/// -- OR --
/// 
/// Setting the env to:
/// ```text
/// SYSLOG_LOGGER_DST_URI_XIO="local#"
/// SYSLOG_LOGGER_LOG_FACILITY_XIO="LOG_DAEMON"
/// SYSLOG_LOGGER_LOG_FORMATTER_XIO="RFC3146"
/// SYSLOG_LOGGER_LOG_IDENTITY_XIO="xio0"
/// ```
/// 
/// should be initialized with:
/// 
/// ```ignore
/// init_event_log(Some("XIO")).unwrap();
/// ```
#[cfg(all(feature = "build_with_thread_local", not(feature = "logger_lazy")))]
pub 
fn init_thread_local_event_log(env_suffix: Option<&str>) -> SyRes<()>
{
    let Some(syslog) = internal_init_event_log::<SyThreadLocal>(env_suffix)?
        else { return Ok(()) };

    logger_cells::LOGGER_LOCAL.set(Some(syslog));

    return Ok(());
}



/// Attaches to the already existing instance of type [SyShared].
/// 
/// This is usefull when a executable software whant to receive messages from the
/// crate which uses `logger`.
/// 
/// Cannot be called twice! An error will be returned.
#[cfg(not(feature = "logger_lazy"))]
pub 
fn attach_event_log_shared<F, D>(sy: &Syslog<F, D, SyShared>) -> SyRes<()>
where 
    F: SyslogFormatter,
    D: SyslogDestination,
{
    let clonned_sy = sy.clone().make_dyn();

    logger_cells::LOGGER
        .set(clonned_sy)
        .map_err(|_e|
            map_error!("syslog instance has been already initialized!")
        )
}

/// Attaches to the already existing instance of type [SyQueued].
/// 
/// This is usefull when a executable software whant to receive messages from the
/// crate which uses `logger`.
/// 
/// Cannot be called twice! An error will be returned.
#[cfg(all(feature = "build_with_queue", not(feature = "logger_lazy")))]
pub 
fn attach_event_log_queued<F, D, S>(sy: &Syslog<F, D, SyQueued<S, F, D>>) -> SyRes<()>
where 
    F: SyslogFormatter,
    D: SyslogDestination,
    S: SyslogQueueChannel<F, D>
{
    let clonned_sy = sy.clone().make_dyn();

    logger_cells::LOGGER
        .set(clonned_sy)
        .map_err(|_e|
            map_error!("syslog instance has been already initialized!")
        )
}

fn internal_init_event_log<OUT: LoggerDynRet>(env_suffix: Option<&str>) -> SyRes<Option<OUT::RetType>> //Box<dyn DynSyslog + Send + Sync>
{
    let Some(envs) = EnvVars::read_env(env_suffix)?
        else { return Ok(None) };

    let dst = LoggerDst::from_str(&envs.logger_type_res)?;
    
    match dst
    {
        LoggerDst::LoLocal{ dst_path } =>
        {
            let tap = 
                if let Some(dst_path) = dst_path
                {
                    SyslogLocal::new_custom_path(dst_path, false)?
                }
                else
                {
                    SyslogLocal::new()
                };

            let mut syslog_inst = 
                match envs.logger_formatter
                {
                    SyslogFormatters::FormatRfc3146 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc3146, SyslogLocal>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                    SyslogFormatters::FormatRfc5424 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc5424, SyslogLocal>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                    SyslogFormatters::FormatFile => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatFile, SyslogLocal>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                };

            OUT::set_prio(&mut syslog_inst, envs.logger_upto)?;

            return Ok(Some(syslog_inst));
        },
        #[cfg(feature = "build_ext_net")]
        LoggerDst::LoUdp{ dst_host } => 
        {
            let tap = SyslogNetUdp::new(dst_host, None)?;
            
            let mut syslog_inst = 
                match envs.logger_formatter
                {
                    SyslogFormatters::FormatRfc3146 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc3146, SyslogNetUdp>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                    SyslogFormatters::FormatRfc5424 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc5424, SyslogNetUdp>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                    SyslogFormatters::FormatFile => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatFile, SyslogNetUdp>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    }
                };
                
            OUT::set_prio(&mut syslog_inst, envs.logger_upto)?;

            return Ok(Some(syslog_inst));
        },
        #[cfg(feature = "build_ext_net")]
        LoggerDst::LoTcp{ dst_host } => //SyslogNetTcp
        {
            let tap = SyslogNetTcp::new(dst_host, None, None)?;
            
            let mut syslog_inst = 
                match envs.logger_formatter
                {
                    SyslogFormatters::FormatRfc3146 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc3146, SyslogNetTcp>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                    SyslogFormatters::FormatRfc5424 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc5424, SyslogNetTcp>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                    SyslogFormatters::FormatFile => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatFile, SyslogNetTcp>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    }
                };
                
            OUT::set_prio(&mut syslog_inst, envs.logger_upto)?;

            return Ok(Some(syslog_inst));
        },

        #[cfg(feature = "build_ext_tls")]
        LoggerDst::LoTls{ dst_host, serv_name, root_cert_path } => 
        {
            let tap = SyslogTls::new2(dst_host, None, serv_name, root_cert_path, None)?;

            let mut syslog_inst = 
                match envs.logger_formatter
                {
                    SyslogFormatters::FormatRfc3146 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc3146, SyslogTls>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                    SyslogFormatters::FormatRfc5424 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc5424, SyslogTls>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID,envs. logger_facility, tap)?
                    },
                    SyslogFormatters::FormatFile => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatFile, SyslogTls>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    }
                };
                
            OUT::set_prio(&mut syslog_inst, envs.logger_upto)?;

            return Ok(Some(syslog_inst));
        },

         #[cfg(feature = "build_ext_file")]
        LoggerDst::LoFile{ dst_path } => 
        {
            let tap = SyslogFile::new(dst_path);

            let mut syslog_inst = 
                match envs.logger_formatter
                {
                    SyslogFormatters::FormatRfc3146 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc3146, SyslogFile>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                    SyslogFormatters::FormatRfc5424 => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatRfc5424, SyslogFile>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    },
                    SyslogFormatters::FormatFile => 
                    {
                        OUT::
                            openlog_with
                                ::<FormatFile, SyslogFile>(envs.logger_identity, 
                                    LogStat::LOG_CONS | LogStat::LOG_NDELAY | LogStat::LOG_PID, envs.logger_facility, tap)?
                    }
                };
                
            OUT::set_prio(&mut syslog_inst, envs.logger_upto)?;

            return Ok(Some(syslog_inst));
        }
    }
}

/// Sends message via logger.
#[cfg(all(feature = "build_with_thread_local", not(feature = "logger_lazy")))]
pub 
fn logger_log(pri: Priority, msg: String)
{
    if let Some(logger) = logger_cells::LOGGER.get()
    {
        let _ = logger.syslog(pri, msg);
    }
    else
    {
        logger_cells::LOGGER_LOCAL
            .with_borrow_mut(
                |b|
                {
                    let Some(logger) = b
                    else { return; };

                    let _ = logger.syslog(pri, msg);
                }
            );
    }
}

#[cfg(all(not(feature = "build_with_thread_local"), not(feature = "logger_lazy")))]
pub 
fn logger_log(pri: Priority, msg: String)
{
    let Some(logger) = logger_cells::LOGGER.get()
        else { return; };

    let _ = logger.syslog(pri, msg);
}

#[cfg(all(feature = "logger_lazy"))]
pub 
fn logger_log(pri: Priority, msg: String)
{
    let Some(logger) = logger_lazy::LOGGER.as_ref()
        else { return; };

    let _ = logger.syslog(pri, msg);
}

/// Sends a message with the [Priority::LOG_DEBUG].
#[macro_export]
macro_rules! logger_dbg
{
    ($($arg:tt)*) => (
        $crate::logger::logger_log($crate::Priority::LOG_DEBUG, format!($($arg)*))
    )
}

/// Sends a message with the [Priority::LOG_INFO].
#[macro_export]
macro_rules! logger_info
{
    ($($arg:tt)*) => (
        $crate::logger::logger_log($crate::Priority::LOG_INFO, format!($($arg)*))
    )
}

/// Sends a message with the [Priority::LOG_ERR].
#[macro_export]
macro_rules! logger_error
{
    ($($arg:tt)*) => (
        $crate::logger::logger_log($crate::Priority::LOG_ERR, format!($($arg)*))
    )
}

/// Sends a message with the [Priority::LOG_WARNING].
#[macro_export]
macro_rules! logger_warn
{
    ($($arg:tt)*) => (
        $crate::logger::logger_log($crate::Priority::LOG_WARNING, format!($($arg)*))
    )
}

/// Sends a message with the [Priority::LOG_EMERG].
#[macro_export]
macro_rules! logger_emerg
{
    ($($arg:tt)*) => (
        $crate::logger::logger_log($crate::Priority::LOG_EMERG, format!($($arg)*))
    )
}

/// Sends a message with the user defined priority.
#[macro_export]
macro_rules! logger_custom
{
    ($prio:expr, $($arg:tt)*) => (
        $crate::logger::logger_log($prio, format!($($arg)*))
    )
}


#[test]
fn test_parsing_logger()
{
    let res = LoggerDst::from_str("local#").unwrap();
    assert_eq!(res, LoggerDst::LoLocal { dst_path: None });

    let res = LoggerDst::from_str("local#/var/run/syslogcustom").unwrap();
    assert_eq!(res, LoggerDst::LoLocal { dst_path: Some("/var/run/syslogcustom") });

    #[cfg(feature = "build_ext_net")]
    {
        let res = LoggerDst::from_str("udp#127.0.0.1:80").unwrap();
        assert_eq!(res, LoggerDst::LoUdp { dst_host: "127.0.0.1:80" });

        let res = LoggerDst::from_str("udp#[fe00:::0]:80").unwrap();
        assert_eq!(res, LoggerDst::LoUdp { dst_host: "[fe00:::0]:80" });

        let res = LoggerDst::from_str("udp#www.mydomain.tdl:80").unwrap();
        assert_eq!(res, LoggerDst::LoUdp { dst_host: "www.mydomain.tdl:80" });


        let res = LoggerDst::from_str("tcp#127.0.0.1:80").unwrap();
        assert_eq!(res, LoggerDst::LoTcp { dst_host: "127.0.0.1:80" });

        let res = LoggerDst::from_str("tcp#[fe00:::0]:80").unwrap();
        assert_eq!(res, LoggerDst::LoTcp { dst_host: "[fe00:::0]:80" });

        let res = LoggerDst::from_str("tcp#www.mydomain.tdl:80").unwrap();
        assert_eq!(res, LoggerDst::LoTcp { dst_host: "www.mydomain.tdl:80" });
    }


    #[cfg(feature = "build_ext_tls")]
    {
        let res = LoggerDst::from_str("tls#127.0.0.1:80#servername#/tmp/a1.crt").unwrap();
        assert_eq!(res, LoggerDst::LoTls { dst_host: "127.0.0.1:80", serv_name: "servername", root_cert_path: "/tmp/a1.crt" });

        let res = LoggerDst::from_str("tls#[fe00:::0]:80#servername#/tmp/a1.crt").unwrap();
        assert_eq!(res, LoggerDst::LoTls { dst_host: "[fe00:::0]:80", serv_name: "servername", root_cert_path: "/tmp/a1.crt" });

        let res = LoggerDst::from_str("tls#www.mydomain.tdl#servername#/tmp/a1.crt").unwrap();
        assert_eq!(res, LoggerDst::LoTls { dst_host: "www.mydomain.tdl", serv_name: "servername", root_cert_path: "/tmp/a1.crt" });
    }

    #[cfg(feature = "build_ext_file")]
    {
        let res = LoggerDst::from_str("file#/tmp/file1.txt").unwrap();
        assert_eq!(res, LoggerDst::LoFile { dst_path: "/tmp/file1.txt" });
    }
}

#[test]
fn test_env_set()
{
    unsafe { env::set_var(SYSLOG_LOGGER_DST_URI, "file#/tmp/test_log1.txt") };
    unsafe { env::set_var(SYSLOG_LOGGER_LOG_FACILITY, "LOG_DAEMON") };
    unsafe { env::set_var(SYSLOG_LOGGER_LOG_FORMATTER, "FILE") };
    unsafe { env::set_var(SYSLOG_LOGGER_LOG_IDENTITY, "test_logger_file") };

    let re = EnvVars::read_env(None).unwrap().unwrap();

    assert_eq!(re.logger_type_res.as_str(), "file#/tmp/test_log1.txt");
    assert_eq!(re.logger_facility, LogFacility::LOG_DAEMON);
    assert_eq!(re.logger_formatter, SyslogFormatters::FormatFile);
    assert_eq!(re.logger_identity.as_ref().map(|v| v.as_str()), Some("test_logger_file"));
}

#[test]
fn test_env_set_suffix()
{
    let suf_xio = Some("XIO");
    unsafe { env::set_var(derive_suffix(suf_xio, SYSLOG_LOGGER_DST_URI).as_ref(), "file#/tmp/xio_out.txt") };
    unsafe { env::set_var(derive_suffix(suf_xio, SYSLOG_LOGGER_LOG_FACILITY).as_ref(), "LOG_DAEMON") };
    unsafe { env::set_var(derive_suffix(suf_xio, SYSLOG_LOGGER_LOG_FORMATTER).as_ref(), "FILE") };
    unsafe { env::set_var(derive_suffix(suf_xio, SYSLOG_LOGGER_LOG_IDENTITY).as_ref(), "xio_rs") };

    let suf_so9 = Some("SOCKET9");
    unsafe { env::set_var(derive_suffix(suf_so9, SYSLOG_LOGGER_DST_URI).as_ref(), "file#/tmp/socket9_out.txt") };
    unsafe { env::set_var(derive_suffix(suf_so9, SYSLOG_LOGGER_LOG_FACILITY).as_ref(), "LOG_DAEMON") };
    unsafe { env::set_var(derive_suffix(suf_so9, SYSLOG_LOGGER_LOG_FORMATTER).as_ref(), "FILE") };
    unsafe { env::set_var(derive_suffix(suf_so9, SYSLOG_LOGGER_LOG_IDENTITY).as_ref(), "socket9") };

    let re = EnvVars::read_env(suf_so9).unwrap().unwrap();

    assert_eq!(re.logger_type_res.as_str(), "file#/tmp/socket9_out.txt");
    assert_eq!(re.logger_facility, LogFacility::LOG_DAEMON);
    assert_eq!(re.logger_formatter, SyslogFormatters::FormatFile);
    assert_eq!(re.logger_identity.as_ref().map(|v| v.as_str()), Some("socket9"));
}

#[test]
fn test_env_set2()
{
    unsafe { env::remove_var(SYSLOG_LOGGER_DST_URI) };
    unsafe { env::set_var(SYSLOG_LOGGER_LOG_FACILITY, "LOG_DAEMON") };
    unsafe { env::set_var(SYSLOG_LOGGER_LOG_FORMATTER, "FILE") };
    unsafe { env::set_var(SYSLOG_LOGGER_LOG_IDENTITY, "test_logger_file") };

    let re = EnvVars::read_env(None).unwrap();
    assert_eq!(re.is_none(), true);
}