Logger.hpp

Go to the documentation of this file.

#pragma once
#ifndef LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGER_HPP_INCLUDED
#define LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGER_HPP_INCLUDED
 
 
#include "config.hpp"
#include "loggers/ILogger.hpp"
#include "formatter.hpp"
#include "detail/TaskExecutor.hpp"
#include <memory>
#include <mutex>
#include <sstream>
#include <atomic>
#include <cstddef>
#include <vector>
 
#if __cplusplus >= 201703L
#include <shared_mutex>
#define LOGIT_HAS_SHARED_MUTEX 1
#else
#define LOGIT_HAS_SHARED_MUTEX 0
#endif
 
namespace logit {
 
#if LOGIT_HAS_SHARED_MUTEX
    using LoggerMutex = std::shared_mutex;
    using LoggerReadLock = std::shared_lock<LoggerMutex>;
    using LoggerWriteLock = std::unique_lock<LoggerMutex>;
#else
    using LoggerMutex = std::mutex;
    using LoggerReadLock = std::unique_lock<LoggerMutex>;
    using LoggerWriteLock = std::unique_lock<LoggerMutex>;
#endif
 
    class Logger {
    private:
        struct LoggerStrategy;
        using StrategyList = std::vector<std::shared_ptr<LoggerStrategy>>;
 
    public:
 
        static Logger& get_instance() {
            static Logger* instance = new Logger();
            return *instance;
        }
 
        void add_logger(
                std::unique_ptr<ILogger> logger,
                std::unique_ptr<ILogFormatter> formatter,
                bool single_mode = false) {
            if (m_shutdown.load(std::memory_order_acquire)) return;
            auto strategy = std::make_shared<LoggerStrategy>();
            strategy->logger = std::move(logger);
            strategy->formatter = std::move(formatter);
            strategy->single_mode = single_mode;
            strategy->enabled = true;
 
            LoggerWriteLock lock(m_loggers_mx);
            if (m_shutdown.load(std::memory_order_acquire)) return;
            m_loggers.push_back(std::move(strategy));
            publish_strategy_snapshot_locked();
        }
 
        void set_logger_enabled(int logger_index, bool enabled) {
            if (m_shutdown) return;
            LoggerWriteLock lock(m_loggers_mx);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size()) && m_loggers[logger_index]) {
                m_loggers[logger_index]->enabled.store(enabled, std::memory_order_relaxed);
            }
        }
 
        bool is_logger_enabled(int logger_index) const {
            LoggerReadLock lock(m_loggers_mx);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size()) && m_loggers[logger_index]) {
                return m_loggers[logger_index]->enabled.load(std::memory_order_relaxed);
            }
            return false;
        }
 
        void set_logger_single_mode(int logger_index, bool single_mode) {
            if (m_shutdown) return;
            LoggerWriteLock lock(m_loggers_mx);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size()) && m_loggers[logger_index]) {
                m_loggers[logger_index]->single_mode.store(single_mode, std::memory_order_relaxed);
            }
        }
 
        void set_timestamp_offset(int logger_index, int64_t offset_ms) {
            if (m_shutdown) return;
            LoggerWriteLock lock(m_loggers_mx);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size()) && m_loggers[logger_index]) {
                std::lock_guard<std::mutex> exec_lock(m_loggers[logger_index]->exec_mx);
                m_loggers[logger_index]->formatter->set_timestamp_offset(offset_ms);
            }
        }
 
        void set_log_level(LogLevel level) {
            if (m_shutdown) return;
            LoggerReadLock lock(m_loggers_mx);
            for (auto& strategy : m_loggers) {
                if (!strategy) continue;
                std::lock_guard<std::mutex> exec_lock(strategy->exec_mx);
                strategy->logger->set_log_level(level);
            }
        }
 
        void set_log_level(int logger_index, LogLevel level) {
            if (m_shutdown) return;
            LoggerWriteLock lock(m_loggers_mx);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size()) && m_loggers[logger_index]) {
                std::lock_guard<std::mutex> exec_lock(m_loggers[logger_index]->exec_mx);
                m_loggers[logger_index]->logger->set_log_level(level);
            }
        }
 
        bool is_logger_single_mode(int logger_index) const {
            if (m_shutdown) return false;
            LoggerReadLock lock(m_loggers_mx);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size()) && m_loggers[logger_index]) {
                return m_loggers[logger_index]->single_mode.load(std::memory_order_relaxed);
            }
            return false;
        }
 
        void log(const LogRecord& record) {
            if (m_shutdown.load(std::memory_order_acquire)) return;
 
            const bool targeted = record.logger_index >= 0;
#ifdef LOGIT_BENCH_LEGACY_REGISTRY
            StrategyList legacy_snapshot;
            {
                LoggerReadLock legacy_lock(m_loggers_mx);
                if (targeted) {
                    if (record.logger_index < static_cast<int>(m_loggers.size())) {
                        legacy_snapshot.push_back(m_loggers[record.logger_index]);
                    }
                } else {
                    legacy_snapshot = m_loggers;
                }
            }
            const StrategyList* strategies = &legacy_snapshot;
            // The targeted legacy snapshot contains only the selected strategy,
            // so dispatch must address its sole element rather than the original
            // registry index.  The production snapshot retains the full registry
            // and continues to use record.logger_index below.
            const int strategy_index = targeted ? 0 : record.logger_index;
#else
            const auto snapshot = std::atomic_load_explicit(
                    &m_loggers_snapshot, std::memory_order_acquire);
            const StrategyList* strategies = snapshot ? snapshot.get() : nullptr;
            const int strategy_index = record.logger_index;
#endif
            if (!strategies) return;
 
            if (targeted) {
                if (strategy_index < 0 ||
                    strategy_index >= static_cast<int>(strategies->size())) return;
                const auto& strategy = (*strategies)[strategy_index];
                if (!strategy) return;
 
                std::lock_guard<std::mutex> exec_lock(strategy->exec_mx);
                if (m_shutdown.load(std::memory_order_acquire)) return;
                if (!strategy->enabled.load(std::memory_order_relaxed)) return;
                if (!record.raw_mode &&
                    static_cast<int>(record.log_level) < static_cast<int>(strategy->logger->get_log_level())) return;
                dispatch_to_strategy(*strategy, record);
                return;
            }
 
            for (const auto& strategy : *strategies) {
                if (!strategy) continue;
 
                std::lock_guard<std::mutex> exec_lock(strategy->exec_mx);
                if (m_shutdown.load(std::memory_order_acquire)) return;
                if (strategy->single_mode.load(std::memory_order_relaxed)) continue;
                if (!strategy->enabled.load(std::memory_order_relaxed)) continue;
                if (!record.raw_mode &&
                    static_cast<int>(record.log_level) < static_cast<int>(strategy->logger->get_log_level())) continue;
 
                dispatch_to_strategy(*strategy, record);
            }
        }
 
        std::string get_string_param(int logger_index, const LoggerParam& param) const {
            if (m_shutdown) return std::string();
            LoggerReadLock lock(m_loggers_mx);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size()) && m_loggers[logger_index]) {
                const auto& strategy = m_loggers[logger_index];
                return strategy->logger->get_string_param(param);
            }
            return std::string();
        }
 
        int64_t get_int_param(int logger_index, const LoggerParam& param) const {
            if (m_shutdown) return 0;
            LoggerReadLock lock(m_loggers_mx);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size()) && m_loggers[logger_index]) {
                const auto& strategy = m_loggers[logger_index];
                return strategy->logger->get_int_param(param);
            }
            return 0;
        }
 
        double get_float_param(int logger_index, const LoggerParam& param) const {
            if (m_shutdown) return 0.0;
            LoggerReadLock lock(m_loggers_mx);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size()) && m_loggers[logger_index]) {
                const auto& strategy = m_loggers[logger_index];
                return strategy->logger->get_float_param(param);
            }
            return 0.0;
        }
 
        std::vector<std::string> get_buffered_strings(int logger_index) const {
            if (m_shutdown) return std::vector<std::string>();
 
            auto strategy = get_strategy_snapshot(logger_index);
            if (!strategy) {
                return std::vector<std::string>();
            }
 
            return strategy->logger->get_buffered_strings();
        }
 
        std::vector<BufferedLogEntry> get_buffered_entries(int logger_index) const {
            if (m_shutdown) return std::vector<BufferedLogEntry>();
 
            auto strategy = get_strategy_snapshot(logger_index);
            if (!strategy) {
                return std::vector<BufferedLogEntry>();
            }
 
            return strategy->logger->get_buffered_entries();
        }
 
        std::vector<LogFileInfo> list_log_files(int logger_index) const {
            if (m_shutdown) return std::vector<LogFileInfo>();
 
            auto strategy = get_strategy_snapshot(logger_index);
            if (!strategy) {
                return std::vector<LogFileInfo>();
            }
 
            return strategy->logger->list_log_files();
        }
 
        LogFileReadResult read_log_file(int logger_index, const std::string& path) const {
            if (m_shutdown) {
                LogFileReadResult result;
                result.file.path = path;
                result.ok = false;
                return result;
            }
 
            auto strategy = get_strategy_snapshot(logger_index);
            if (!strategy) {
                LogFileReadResult result;
                result.file.path = path;
                result.ok = false;
                return result;
            }
 
            return strategy->logger->read_log_file(path);
        }
 
        std::vector<LogFileReadResult> read_log_files(int logger_index, const std::vector<std::string>& paths) const {
            if (m_shutdown) {
                std::vector<LogFileReadResult> results;
                results.reserve(paths.size());
                for (size_t i = 0; i < paths.size(); ++i) {
                    LogFileReadResult result;
                    result.file.path = paths[i];
                    result.ok = false;
                    results.push_back(result);
                }
                return results;
            }
 
            auto strategy = get_strategy_snapshot(logger_index);
            if (!strategy) {
                std::vector<LogFileReadResult> results;
                results.reserve(paths.size());
                for (size_t i = 0; i < paths.size(); ++i) {
                    LogFileReadResult result;
                    result.file.path = paths[i];
                    result.ok = false;
                    results.push_back(result);
                }
                return results;
            }
 
            return strategy->logger->read_log_files(paths);
        }
 
        LogLevel get_log_level(int logger_index) const {
            if (m_shutdown) return LogLevel::LOG_LVL_TRACE;
 
            auto strategy = get_strategy_snapshot(logger_index);
            if (!strategy) {
                return LogLevel::LOG_LVL_TRACE;
            }
 
            return strategy->logger->get_log_level();
        }
 
        template <typename... Ts>
        auto log_and_return(const LogRecord& record, Ts&&... args) -> decltype(std::forward_as_tuple(std::forward<Ts>(args)...)) {
            this->print(record, args...);
            return std::forward_as_tuple(std::forward<Ts>(args)...);
        }
 
        template <typename T>
        auto log_and_return(const LogRecord& record, T&& args) -> decltype(args) {
            this->print(record, args);
            return std::forward<decltype(args)>(args);
        }
 
        auto log_and_return(const LogRecord& record) -> std::tuple<> {
            this->print(record);
            return {};
        }
 
        void wait() {
            const auto snapshot = get_all_strategy_snapshots();
            for (const auto& strategy : snapshot) {
                if (!strategy) continue;
                strategy->logger->wait();
            }
        }
 
        LogClearResult clear_logger(int logger_index, const LogClearOptions& options = LogClearOptions()) {
            LogClearResult result;
            if (m_shutdown.load(std::memory_order_acquire)) {
                result.ok = false;
                result.status = LogClearStatus::Failed;
                result.message = "logger system is shut down";
                return result;
            }
 
            auto strategy = get_strategy_snapshot(logger_index);
            if (!strategy) {
                result.ok = false;
                result.status = LogClearStatus::Failed;
                result.message = "logger index not found";
                return result;
            }
 
            std::lock_guard<std::mutex> exec_lock(strategy->exec_mx);
            if (m_shutdown.load(std::memory_order_acquire)) {
                result.ok = false;
                result.status = LogClearStatus::Failed;
                result.message = "logger system is shut down";
                return result;
            }
            return strategy->logger->clear_logs(options);
        }
 
        LogClearResult clear_all_loggers(const LogClearOptions& options = LogClearOptions()) {
            LogClearResult result;
            if (m_shutdown.load(std::memory_order_acquire)) {
                result.ok = false;
                result.status = LogClearStatus::Failed;
                result.message = "logger system is shut down";
                return result;
            }
 
            const auto snapshot = get_all_strategy_snapshots();
            std::size_t supported = 0;
            std::size_t failed = 0;
            std::size_t unsupported = 0;
            for (const auto& strategy : snapshot) {
                if (!strategy) continue;
                std::lock_guard<std::mutex> exec_lock(strategy->exec_mx);
                if (m_shutdown.load(std::memory_order_acquire)) {
                    result.ok = false;
                    result.status = LogClearStatus::Failed;
                    result.message = "logger system is shut down";
                    return result;
                }
                const LogClearResult one = strategy->logger->clear_logs(options);
                if (one.status == LogClearStatus::Cleared && one.ok) {
                    ++supported;
                    result.cleared_records += one.cleared_records;
                } else if (one.status == LogClearStatus::Unsupported) {
                    ++unsupported;
                } else {
                    ++failed;
                    if (result.message.empty()) {
                        result.message = one.message;
                    }
                }
            }
 
            result.ok = supported > 0 && failed == 0;
            if (result.ok) {
                result.status = LogClearStatus::Cleared;
                result.message = unsupported > 0 ? "cleared supported loggers; skipped unsupported loggers" : "cleared";
            } else {
                result.status = unsupported > 0 && failed == 0 ? LogClearStatus::Unsupported : LogClearStatus::Failed;
                if (result.message.empty()) {
                    result.message = unsupported > 0 ? "no logger supports clearing" : "no loggers to clear";
                }
            }
            return result;
        }
 
        std::size_t logger_count() const {
            LoggerReadLock lock(m_loggers_mx);
            return m_loggers.size();
        }
 
        template <typename LoggerT>
        LoggerT* get_logger_as(int logger_index) {
            auto strategy = get_strategy_snapshot(logger_index);
            return (strategy && strategy->logger)
                ? dynamic_cast<LoggerT*>(strategy->logger.get())
                : nullptr;
        }
 
        template <typename LoggerT>
        const LoggerT* get_logger_as(int logger_index) const {
            auto strategy = get_strategy_snapshot(logger_index);
            return (strategy && strategy->logger)
                ? dynamic_cast<const LoggerT*>(strategy->logger.get())
                : nullptr;
        }
 
        void shutdown() {
            if (m_shutdown.exchange(true, std::memory_order_acq_rel)) return;
 
            const auto snapshot = get_all_strategy_snapshots();
            for (const auto& strategy : snapshot) {
                if (!strategy) continue;
                std::lock_guard<std::mutex> exec_lock(strategy->exec_mx);
                strategy->logger->shutdown();
            }
            detail::TaskExecutor::get_instance().shutdown();
        }
 
    private:
 
        struct LoggerStrategy {
            std::unique_ptr<ILogger> logger;            
            std::unique_ptr<ILogFormatter> formatter;   
            std::atomic<bool> single_mode{false};       
            std::atomic<bool> enabled{true};            
            mutable std::mutex exec_mx;                 
        };
 
        void dispatch_to_strategy(LoggerStrategy& strategy, const LogRecord& record) {
            if (record.raw_mode) {
                strategy.logger->log(record, record.format);
                return;
            }
            if (strategy.formatter && strategy.formatter->is_passthrough()) {
                strategy.logger->log(record, record.format);
                return;
            }
            const std::string msg = strategy.formatter ? strategy.formatter->format(record) : std::string();
            strategy.logger->log(record, msg);
        }
 
        std::shared_ptr<LoggerStrategy> get_strategy_snapshot(int logger_index) const {
            const auto snapshot = std::atomic_load_explicit(
                    &m_loggers_snapshot, std::memory_order_acquire);
            if (logger_index >= 0 &&
                snapshot && logger_index < static_cast<int>(snapshot->size()) &&
                (*snapshot)[logger_index]) {
                return (*snapshot)[logger_index];
            }
            return std::shared_ptr<LoggerStrategy>();
        }
 
        void publish_strategy_snapshot_locked() {
            const std::shared_ptr<const StrategyList> snapshot(
                    new StrategyList(m_loggers));
            std::atomic_store_explicit(
                    &m_loggers_snapshot, snapshot, std::memory_order_release);
        }
 
        std::vector<std::shared_ptr<LoggerStrategy>> get_all_strategy_snapshots() const {
            LoggerReadLock lock(m_loggers_mx);
            return m_loggers;
        }
 
        std::vector<std::shared_ptr<LoggerStrategy>> m_loggers;        
        std::shared_ptr<const StrategyList> m_loggers_snapshot; 
        mutable LoggerMutex m_loggers_mx;                        
        std::atomic<bool> m_shutdown = ATOMIC_VAR_INIT(false); 
 
        void print(const LogRecord& record) {
            log(record);
        }
        
#ifdef _MSC_VER
#   pragma warning(push)
#   pragma warning(disable: 4127) // conditional expression is constant
#endif
 
        template <typename... Ts>
        void print(const LogRecord& record, Ts const&... args) {
            if (sizeof...(Ts) == 0) {
                log(record);
                return;
            }
            // args_array is mutable cache inside LogRecord
            auto var_names = split_arguments(record.arg_names);
            record.args_array = args_to_array(var_names.begin(), args...);
            log(record);
        }
        
#ifdef _MSC_VER
#   pragma warning(pop)
#endif
 
        Logger() {
            std::atomic_store_explicit(
                    &m_loggers_snapshot,
                    std::shared_ptr<const StrategyList>(new StrategyList()),
                    std::memory_order_release);
            std::atexit(Logger::on_exit_handler);
        }
 
        ~Logger() {
            shutdown();
        }
 
        // Deleting copy and move constructors and assignment operators to enforce singleton.
        Logger(const Logger&) = delete;
        Logger& operator=(const Logger&) = delete;
        Logger(Logger&&) = delete;
        Logger& operator=(Logger&&) = delete;
 
        static void on_exit_handler() {
            Logger::get_instance().shutdown();
        }
    };
 
}; // namespace logit
 
#endif // LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGER_HPP_INCLUDED