WindowsDebugLogger.hpp

Go to the documentation of this file.

#pragma once
#ifndef LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_WINDOWSDEBUGLOGGER_HPP_INCLUDED
#define LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_WINDOWSDEBUGLOGGER_HPP_INCLUDED
 
 
#include "ILogger.hpp"
#include <atomic>
#include <string>
#include <iostream>
#include <memory>
#include <mutex>
 
#if defined(_WIN32)
#include <windows.h>
#endif
 
namespace logit {
 
    class WindowsDebugLogger : public ILogger {
    public:
 
        struct Config {
#ifdef __EMSCRIPTEN__
            explicit Config(bool async_value = false)
#else
            explicit Config(bool async_value = true)
#endif
                : async(async_value)
                , use_dedicated_executor(false)
                , queue_capacity(0)
                , queue_policy(QueuePolicy::Block) {}
 
            bool async; 
            bool use_dedicated_executor; 
            std::size_t queue_capacity;       
            QueuePolicy queue_policy; 
        };
 
        WindowsDebugLogger() : WindowsDebugLogger(Config()) {}
 
        explicit WindowsDebugLogger(const Config& config) : m_config(config) {
            if (m_config.async && m_config.use_dedicated_executor) {
                m_executor.reset(new detail::SingleThreadExecutor());
                m_executor->set_max_queue_size(m_config.queue_capacity);
                m_executor->set_queue_policy(m_config.queue_policy);
            }
        }
 
        WindowsDebugLogger(
                bool async,
                bool use_dedicated_executor,
                std::size_t queue_capacity,
                QueuePolicy queue_policy)
            : WindowsDebugLogger(make_config(
                    async,
                    use_dedicated_executor,
                    queue_capacity,
                    queue_policy)) {}
 
        void set_config(const Config& config) {
            std::unique_ptr<detail::SingleThreadExecutor> old_executor;
            {
                std::unique_lock<std::mutex> lock(m_lifecycle_mutex);
                if (m_shutdown.load(std::memory_order_acquire)) return;
                if (m_config.async) {
                    if (m_executor) {
                        m_executor->wait();
                    } else {
                        detail::TaskExecutor::get_instance().wait();
                    }
                }
                m_config.async = config.async;
                m_config.use_dedicated_executor = config.use_dedicated_executor;
                m_config.queue_capacity = config.queue_capacity;
                m_config.queue_policy = config.queue_policy;
                if (m_config.async && m_config.use_dedicated_executor) {
                    if (!m_executor) {
                        m_executor.reset(new detail::SingleThreadExecutor());
                    }
                    m_executor->set_max_queue_size(m_config.queue_capacity);
                    m_executor->set_queue_policy(m_config.queue_policy);
                } else if (m_executor) {
                    old_executor = std::move(m_executor);
                    m_executor.reset();
                }
            }
            if (old_executor) {
                old_executor->shutdown();
            }
        }
 
        bool set_queue_config(std::size_t queue_capacity,
                              QueuePolicy queue_policy) {
            std::lock_guard<std::mutex> lifecycle_lock(m_lifecycle_mutex);
 
            if (m_shutdown.load(std::memory_order_acquire)) {
                return false;
            }
 
            m_config.queue_capacity = queue_capacity;
            m_config.queue_policy = queue_policy;
 
            if (!m_executor) {
                return false;
            }
 
            m_executor->set_max_queue_size(queue_capacity);
            m_executor->set_queue_policy(queue_policy);
            return true;
        }
 
        void log(const LogRecord& record, const std::string& message) override {
            std::lock_guard<std::mutex> lifecycle_lock(m_lifecycle_mutex);
            if (m_shutdown.load(std::memory_order_acquire)) return;
            if (m_config.async) {
                if (m_executor) {
                    m_executor->add_task([message]() {
                        write_impl(message);
                    });
                } else {
                    detail::TaskExecutor::get_instance().add_task([message]() {
                        write_impl(message);
                    });
                }
            } else {
                write_impl(message);
            }
            m_last_log_ts.store(record.timestamp_ms);
        }
 
        std::string get_string_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp:
                return std::to_string(m_last_log_ts.load());
            default:
                break;
            }
            return {};
        }
 
        int64_t get_int_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp:
                return m_last_log_ts.load();
            default:
                break;
            }
            return 0;
        }
 
        double get_float_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp:
                return static_cast<double>(m_last_log_ts.load()) / 1000.0;
            default:
                break;
            }
            return 0.0;
        }
 
        void set_log_level(LogLevel level) override {
            m_log_level = static_cast<int>(level);
        }
 
        LogLevel get_log_level() const override {
            return static_cast<LogLevel>(m_log_level.load());
        }
 
        void wait() override {
            std::lock_guard<std::mutex> lifecycle_lock(m_lifecycle_mutex);
            if (!m_config.async) return;
            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_config.async) {
                detail::TaskExecutor::get_instance().wait();
            }
        }
 
    private:
        Config m_config;
        std::mutex m_lifecycle_mutex;
        std::atomic<int> m_log_level{static_cast<int>(LogLevel::LOG_LVL_TRACE)};
        std::atomic<int64_t> m_last_log_ts{0};
        std::atomic<bool> m_shutdown{false};
        std::unique_ptr<detail::SingleThreadExecutor> m_executor;
 
        static Config make_config(
                bool async,
                bool use_dedicated_executor,
                std::size_t queue_capacity,
                QueuePolicy queue_policy) {
            Config config(async);
            config.use_dedicated_executor = use_dedicated_executor;
            config.queue_capacity = queue_capacity;
            config.queue_policy = queue_policy;
            return config;
        }
 
        static void write_impl(const std::string& message) {
#if defined(_WIN32)
            // Convert UTF-8 message to wide string for OutputDebugStringW.
            if (message.empty()) {
                OutputDebugStringW(L"\n");
                return;
            }
            const int len = static_cast<int>(message.size());
            const int wlen = MultiByteToWideChar(CP_UTF8, 0, message.c_str(), len, nullptr, 0);
            if (wlen > 0) {
                std::wstring wmsg;
                wmsg.resize(static_cast<size_t>(wlen));
                MultiByteToWideChar(CP_UTF8, 0, message.c_str(), len, &wmsg[0], wlen);
                wmsg += L'\n';
                OutputDebugStringW(wmsg.c_str());
            } else {
                OutputDebugStringA((message + "\n").c_str());
            }
#else
            std::cerr << message << '\n';
#endif
        }
    };
 
} // namespace logit
 
#endif // LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_WINDOWSDEBUGLOGGER_HPP_INCLUDED