EventLogLogger.hpp

Go to the documentation of this file.

#pragma once
#ifndef LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_EVENTLOGLOGGER_HPP_INCLUDED
#define LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_EVENTLOGLOGGER_HPP_INCLUDED
 
#include "ILogger.hpp"
#include <atomic>
#include <string>
#include <memory>
#include <mutex>
 
 
#if defined(_WIN32) && defined(LOGIT_HAS_WIN_EVENT_LOG)
#include <windows.h>
#define LOGIT_WIN_EVENT_ENABLED 1
#else
#define LOGIT_WIN_EVENT_ENABLED 0
#endif
 
namespace logit {
 
#   if LOGIT_WIN_EVENT_ENABLED
 
    class EventLogLogger : public ILogger {
    public:
        struct Config {
            const wchar_t* source; 
            bool async;           
            bool use_dedicated_executor = false; 
            std::size_t queue_capacity = 0;       
            QueuePolicy queue_policy = QueuePolicy::Block; 
            Config(const wchar_t* s = L"LogIt", bool a = true) : source(s), async(a) {}
        };
 
        EventLogLogger() : EventLogLogger(Config()) {}
 
        explicit EventLogLogger(const Config& c) : m_cfg(c) {
            m_hsrc = RegisterEventSourceW(nullptr, m_cfg.source);
            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);
            }
        }
 
        EventLogLogger(const wchar_t* source, bool async)
            : EventLogLogger(Config(source, async)) {}
 
        EventLogLogger(
                const wchar_t* source,
                bool async,
                bool use_dedicated_executor,
                std::size_t queue_capacity,
                QueuePolicy queue_policy)
            : EventLogLogger(make_config(
                    source,
                    async,
                    use_dedicated_executor,
                    queue_capacity,
                    queue_policy)) {}
 
        ~EventLogLogger() override { shutdown(); if (m_hsrc) DeregisterEventSource(m_hsrc); }
 
        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;
                if (!m_hsrc) return;
                WORD type = m_map(lvl);
                int n = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), static_cast<int>(s.size()), nullptr, 0);
                std::wstring wmsg; wmsg.resize(n);
                MultiByteToWideChar(CP_UTF8, 0, s.c_str(), static_cast<int>(s.size()), &wmsg[0], n);
                LPCWSTR arr[1] = { wmsg.c_str() };
                ReportEventW(m_hsrc, type, 0, 0, nullptr, 1, 0, arr, nullptr);
            };
            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 WORD m_map(LogLevel l) {
            switch (l) {
                case LogLevel::LOG_LVL_TRACE:
                case LogLevel::LOG_LVL_DEBUG:
                case LogLevel::LOG_LVL_INFO:  return EVENTLOG_INFORMATION_TYPE;
                case LogLevel::LOG_LVL_WARN:  return EVENTLOG_WARNING_TYPE;
                case LogLevel::LOG_LVL_ERROR: return EVENTLOG_ERROR_TYPE;
                case LogLevel::LOG_LVL_FATAL: return EVENTLOG_ERROR_TYPE;
            } return EVENTLOG_INFORMATION_TYPE;
        }
        Config m_cfg{};
        std::mutex m_lifecycle_mutex;
        HANDLE m_hsrc = nullptr;
        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 wchar_t* source,
                bool async,
                bool use_dedicated_executor,
                std::size_t queue_capacity,
                QueuePolicy queue_policy) {
            Config config(source, async);
            config.use_dedicated_executor = use_dedicated_executor;
            config.queue_capacity = queue_capacity;
            config.queue_policy = queue_policy;
            return config;
        }
    };
 
#   else // stub
    class EventLogLogger : public ILogger {
    public:
        struct Config {
            const wchar_t* source; 
            bool async;           
            bool use_dedicated_executor = false; 
            std::size_t queue_capacity = 0;       
            QueuePolicy queue_policy = QueuePolicy::Block; 
            Config(const wchar_t* s = L"", bool a = false) : source(s), async(a) {}
        };
 
        EventLogLogger() {}
 
        explicit EventLogLogger(const Config& c) { (void)c; }
 
        EventLogLogger(const wchar_t* source, bool async) { (void)source; (void)async; }
 
        EventLogLogger(const wchar_t* source, bool async, bool use_dedicated_executor,
                       std::size_t queue_capacity, QueuePolicy queue_policy) {
            (void)source; (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_EVENTLOGLOGGER_HPP_INCLUDED