SyslogLogger.hpp

Go to the documentation of this file.

#pragma once
#ifndef LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_SYSLOGLOGGER_HPP_INCLUDED
#define LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_SYSLOGLOGGER_HPP_INCLUDED
 
#include "ILogger.hpp"
#include <atomic>
#include <string>
#include <memory>
#include <mutex>
 
 
#if (defined(__unix__) || defined(__APPLE__)) && defined(LOGIT_HAS_SYSLOG)
#include <syslog.h>
#define LOGIT_SYSLOG_ENABLED 1
#else
#define LOGIT_SYSLOG_ENABLED 0
#endif
 
namespace logit {
 
#   if LOGIT_SYSLOG_ENABLED
 
    class SyslogLogger : public ILogger {
    public:
        struct Config {
            const char* ident;  
            int facility;       
            bool async;         
            bool use_dedicated_executor = false; 
            std::size_t queue_capacity = 0;       
            QueuePolicy queue_policy = QueuePolicy::Block; 
            Config(const char* i = "log-it", int f = LOG_USER, bool a = true)
                : ident(i), facility(f), async(a) {}
        };
 
        SyslogLogger() : SyslogLogger(Config()) {}
 
        explicit SyslogLogger(const Config& c) : m_cfg(c) {
            openlog(m_cfg.ident, LOG_PID | LOG_NDELAY, m_cfg.facility);
            if (m_cfg.async && m_cfg.use_dedicated_executor) {
                m_executor.reset(new detail::SingleThreadExecutor());
                m_executor->set_max_queue_size(m_cfg.queue_capacity);
                m_executor->set_queue_policy(m_cfg.queue_policy);
            }
        }
 
        SyslogLogger(const char* ident, int facility, bool async)
            : SyslogLogger(Config(ident, facility, async)) {}
 
        SyslogLogger(
                const char* ident,
                int facility,
                bool async,
                bool use_dedicated_executor,
                std::size_t queue_capacity,
                QueuePolicy queue_policy)
            : SyslogLogger(make_config(
                    ident,
                    facility,
                    async,
                    use_dedicated_executor,
                    queue_capacity,
                    queue_policy)) {}
 
        ~SyslogLogger() override { shutdown(); closelog(); }
 
        void log(const LogRecord& rec, const std::string& msg) override {
            std::lock_guard<std::mutex> lifecycle_lock(m_lifecycle_mutex);
            if (m_shutdown.load(std::memory_order_acquire)) return;
            LogLevel lvl = rec.raw_mode ? LogLevel::LOG_LVL_INFO : rec.log_level;
            bool raw_mode = rec.raw_mode;
            std::string s = msg;
            auto task = [this, lvl, raw_mode, s]() {
                if (!raw_mode && static_cast<int>(lvl) < m_level.load()) return;
                syslog(m_map(lvl), "%s", s.c_str());
            };
            if (m_cfg.async) { if (m_executor) { m_executor->add_task(task); } else { detail::TaskExecutor::get_instance().add_task(task); } }
            else { task(); }
            m_last_ts.store(rec.timestamp_ms);
        }
        std::string get_string_param(const LoggerParam& param) const override { return {}; }
 
        int64_t get_int_param(const LoggerParam& param) const override { return 0; }
 
        double  get_float_param(const LoggerParam& param) const override { return 0.0; }
 
        void set_log_level(LogLevel l) override { m_level.store(static_cast<int>(l)); }
 
        LogLevel get_log_level() const override { return static_cast<LogLevel>(m_level.load()); }
 
        void wait() override { if (m_cfg.async) { if (m_executor) { m_executor->wait(); } else { detail::TaskExecutor::get_instance().wait(); } } }
 
        void shutdown() override {
            {
                std::lock_guard<std::mutex> lifecycle_lock(m_lifecycle_mutex);
                if (m_shutdown.exchange(true, std::memory_order_acq_rel)) return;
            }
            if (m_executor) {
                m_executor->shutdown();
            } else if (m_cfg.async) {
                detail::TaskExecutor::get_instance().wait();
            }
        }
 
    private:
        static int m_map(LogLevel l) {
            switch (l) {
                case LogLevel::LOG_LVL_TRACE:
                case LogLevel::LOG_LVL_DEBUG: return LOG_DEBUG;
                case LogLevel::LOG_LVL_INFO:  return LOG_INFO;
                case LogLevel::LOG_LVL_WARN:  return LOG_WARNING;
                case LogLevel::LOG_LVL_ERROR: return LOG_ERR;
                case LogLevel::LOG_LVL_FATAL: return LOG_CRIT;
            } return LOG_INFO;
        }
        Config m_cfg{};
        std::mutex m_lifecycle_mutex;
        std::atomic<int> m_level{static_cast<int>(LogLevel::LOG_LVL_TRACE)};
        std::atomic<int64_t> m_last_ts{0};
        std::atomic<bool> m_shutdown{false};
        std::unique_ptr<detail::SingleThreadExecutor> m_executor;
 
        static Config make_config(
                const char* ident,
                int facility,
                bool async,
                bool use_dedicated_executor,
                std::size_t queue_capacity,
                QueuePolicy queue_policy) {
            Config config(ident, facility, async);
            config.use_dedicated_executor = use_dedicated_executor;
            config.queue_capacity = queue_capacity;
            config.queue_policy = queue_policy;
            return config;
        }
    };
 
#   else // stub on unsupported
    class SyslogLogger : public ILogger {
    public:
        struct Config {
            const char* ident;  
            int facility;       
            bool async;         
            bool use_dedicated_executor = false; 
            std::size_t queue_capacity = 0;       
            QueuePolicy queue_policy = QueuePolicy::Block; 
            Config(const char* i="", int f=0, bool a=false) : ident(i), facility(f), async(a) {}
        };
 
        SyslogLogger() {}
 
        explicit SyslogLogger(const Config& c) { (void)c; }
 
        SyslogLogger(const char* ident,int facility,bool async) { (void)ident; (void)facility; (void)async; }
 
        SyslogLogger(const char* ident, int facility, bool async, bool use_dedicated_executor,
                     std::size_t queue_capacity, QueuePolicy queue_policy) {
            (void)ident; (void)facility; (void)async; (void)use_dedicated_executor;
            (void)queue_capacity; (void)queue_policy;
        }
 
        void log(const LogRecord& rec, const std::string& msg) override { (void)rec; (void)msg; }
 
        std::string get_string_param(const LoggerParam& param) const override { (void)param; return {}; }
 
        int64_t get_int_param(const LoggerParam& param) const override { (void)param; return 0; }
 
        double get_float_param(const LoggerParam& param) const override { (void)param; return 0.0; }
 
        void set_log_level(LogLevel l) override { (void)l; }
 
        LogLevel get_log_level() const override { return LogLevel::LOG_LVL_TRACE; }
 
        void wait() override {}
    };
#   endif
 
} // namespace logit
 
#endif // LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_SYSLOGLOGGER_HPP_INCLUDED