Logger.hpp

Go to the documentation of this file.

#pragma once
#ifndef _LOGIT_LOGGER_HPP_INCLUDED
#define _LOGIT_LOGGER_HPP_INCLUDED
 
#include "Logger/ILogger.hpp"
#include "Formatter/ILogFormatter.hpp"
#include <memory>
#include <mutex>
#include <sstream>
#include <atomic>
 
namespace logit {

    class Logger {
    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) return;
            std::lock_guard<std::mutex> lock(m_mutex);
            m_loggers.push_back(
                LoggerStrategy{std::move(logger),
                std::move(formatter),
                single_mode,
                true // Loggers are enabled by default
            });
        }

        void set_logger_enabled(int logger_index, bool enabled) {
            if (m_shutdown) return;
            std::lock_guard<std::mutex> lock(m_mutex);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                m_loggers[logger_index].enabled = enabled;
            }
        }

        bool is_logger_enabled(int logger_index) const {
            std::lock_guard<std::mutex> lock(m_mutex);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                return m_loggers[logger_index].enabled;
            }
            return false;
        }

        void set_logger_single_mode(int logger_index, bool single_mode) {
            if (m_shutdown) return;
            std::lock_guard<std::mutex> lock(m_mutex);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                m_loggers[logger_index].single_mode = single_mode;
            }
        }

        void set_timestamp_offset(int logger_index, int64_t offset_ms) {
            if (m_shutdown) return;
            std::lock_guard<std::mutex> lock(m_mutex);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                m_loggers[logger_index].formatter->set_timestamp_offset(offset_ms);
            }
        }

        bool is_logger_single_mode(int logger_index) const {
            if (m_shutdown) return false;
            std::lock_guard<std::mutex> lock(m_mutex);
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                return m_loggers[logger_index].single_mode;
            }
            return false;
        }

        void log(const LogRecord& record) {
            if (m_shutdown) return;
            std::lock_guard<std::mutex> lock(m_mutex);
            // Log to the specific logger if the index is valid
            if (record.logger_index >= 0 && record.logger_index < static_cast<int>(m_loggers.size())) {
                const auto& strategy = m_loggers[record.logger_index];
                if (!strategy.enabled) return;
                strategy.logger->log(record, strategy.formatter->format(record));
                return;
            }
            for (const auto& strategy : m_loggers) {
                if (strategy.single_mode) continue;
                if (!strategy.enabled) continue;
                strategy.logger->log(record, strategy.formatter->format(record));
            }
        }

        std::string get_string_param(int logger_index, const LoggerParam& param) const {
            if (m_shutdown) return std::string();
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                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;
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                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;
            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
                const auto& strategy = m_loggers[logger_index];
                return strategy.logger->get_float_param(param);
            }
            return 0.0;
        }

        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() {
            for (const auto& strategy : m_loggers) {
                strategy.logger->wait();
            }
        }

        void shutdown() {
            if (m_shutdown) return;
            m_shutdown = true;
            wait();
            TaskExecutor::get_instance().shutdown();
        }
 
    private:

        struct LoggerStrategy {
            std::unique_ptr<ILogger> logger;            
            std::unique_ptr<ILogFormatter> formatter;   
            bool single_mode;                           
            bool enabled;                               
        };
 
        std::vector<LoggerStrategy> m_loggers;        
        mutable std::mutex m_mutex;                   
        std::atomic<bool> m_shutdown = ATOMIC_VAR_INIT(false); 

        template <typename... Ts>
        void print(const LogRecord& record, Ts const&... args) {
            if (sizeof...(Ts) == 0) {
                log(record);
                return;
            }
            LogRecord mutable_record = record;
            auto var_names = split_arguments(mutable_record.arg_names);
            mutable_record.args_array = args_to_array(var_names.begin(), args...);
            log(mutable_record);
        }
 
        Logger() {
            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_LOGGER_HPP_INCLUDED