FileLogger.hpp

Go to the documentation of this file.

#pragma once
#ifndef _LOGIT_FILE_LOGGER_HPP_INCLUDED
#define _LOGIT_FILE_LOGGER_HPP_INCLUDED

 
#include "ILogger.hpp"
#include <iostream>
#include <fstream>
#include <mutex>
#include <atomic>
#include <regex>
#include <queue>
#include <functional>
#include <time_shield/time_parser.hpp>
 
namespace logit {
 
#if defined(__EMSCRIPTEN__)
 
    class FileLogger : public ILogger {
    public:
        struct Config {
            std::string directory = "logs";
            bool        async     = false;
            int         auto_delete_days = 30;
        };
 
        FileLogger() { warn(); }
        FileLogger(const Config&) { warn(); }
        FileLogger(const std::string&, const bool& = true, const int& = 30) { warn(); }
 
        void log(const LogRecord&, const std::string&) override { warn(); }
        std::string get_string_param(const LoggerParam&) const override { return {}; }
        int64_t get_int_param(const LoggerParam&) const override { return 0; }
        double get_float_param(const LoggerParam&) const override { return 0.0; }
        void set_log_level(LogLevel) override {}
        LogLevel get_log_level() const override { return LogLevel::LOG_LVL_TRACE; }
        void wait() override {}
 
    private:
        void warn() const { std::cerr << "FileLogger is not supported under Emscripten" << std::endl; }
        std::atomic<int> m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));
    };
 
#else

    class FileLogger : public ILogger {
    public:

        struct Config {
            std::string directory           = "logs"; 
            bool        async               = true; 
            int         auto_delete_days    = 30;   
        };

        FileLogger() {
            start_logging();
        }

        FileLogger(const Config& config) : m_config(config) {
            start_logging();
        }

        FileLogger(
                const std::string& directory,
                const bool& async = true,
                const int& auto_delete_days = 30) {
            m_config.directory = directory;
            m_config.async = async;
            m_config.auto_delete_days = auto_delete_days;
            start_logging();
        }

        virtual ~FileLogger() {
            stop_logging();
        }

        void log(const LogRecord& record, const std::string& message) override {
            m_last_log_ts = record.timestamp_ms;
            if (!m_config.async) {
                std::lock_guard<std::mutex> lock(m_mutex);
                try {
                    write_log(message, record.timestamp_ms);
                } catch (const std::exception& e) {
                    std::cerr << "Log error: " << e.what() << std::endl;
                }
                return;
            }
            auto timestamp_ms = record.timestamp_ms;
            TaskExecutor::get_instance().add_task([this, message, timestamp_ms]() {
                std::lock_guard<std::mutex> lock(m_mutex);
                try {
                    write_log(message, timestamp_ms);
                } catch (const std::exception& e) {
                    std::cerr << "Log async log error: " << e.what() << std::endl;
                }
            });
        }

        std::string get_string_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastFileName: return get_last_log_file_name();
            case LoggerParam::LastFilePath: return get_last_log_file_path();
            case LoggerParam::LastLogTimestamp: return std::to_string(get_last_log_ts());
            case LoggerParam::TimeSinceLastLog: return std::to_string(get_time_since_last_log());
            default:
                break;
            };
            return std::string();
        }

        int64_t get_int_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp: return get_last_log_ts();
            case LoggerParam::TimeSinceLastLog: return get_time_since_last_log();
            default:
                break;
            };
            return 0;
        }

        double get_float_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp: return (double)get_last_log_ts() / 1000.0;
            case LoggerParam::TimeSinceLastLog: return (double)get_time_since_last_log() / 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 {
            if (!m_config.async) return;
            TaskExecutor::get_instance().wait();
        }
 
    private:
        mutable std::mutex m_mutex;    
        Config             m_config;   
        std::ofstream      m_file;     
        mutable std::mutex m_file_path_mutex; 
        std::string        m_file_path; 
        std::string        m_file_name; 
        int64_t            m_current_date_ts = 0; 
        std::atomic<int64_t> m_last_log_ts = ATOMIC_VAR_INIT(0); 
        std::atomic<int>    m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));

        void start_logging() {
            // I/O streams (e.g., std::cin, std::cout, std::cerr) may be closed before the program exits.
            // In this case, calls to functions that use I/O streams (for example, the std::regex constructor)
            // can lead to undesirable behavior such as hangs or segmentation faults.
            is_valid_log_filename("2024-01-01.log");
            std::lock_guard<std::mutex> lock(m_mutex);
            try {
                initialize_directory();
                open_log_file(get_current_utc_date_ts());
                remove_old_logs();
            } catch (const std::exception& e) {
                std::cerr << "Initialization error: " << e.what() << std::endl;
            }
        }

        void stop_logging() {
            wait();
            std::lock_guard<std::mutex> lock(m_mutex);
            if (m_file.is_open()) {
                m_file.close();
            }
        }

        void initialize_directory() {
            create_directories(get_directory_path());
        }

        std::string get_directory_path() const {
#           if defined(_WIN32)
            return get_exec_dir() + "\\" + m_config.directory;
#           else
            return get_exec_dir() + "/" + m_config.directory;
#           endif
        }

        void open_log_file(const int64_t& date_ts) {
            if (m_file.is_open()) {
                m_file.close();
            }
            m_current_date_ts = date_ts;
            std::unique_lock<std::mutex> lock(m_file_path_mutex);
            m_file_path = create_file_path(date_ts);
            m_file_name = get_file_name(m_file_path);
            lock.unlock();
#           if defined(_WIN32)
            m_file.open(utf8_to_ansi(m_file_path), std::ios_base::app);
#           else
            m_file.open(m_file_path, std::ios_base::app);
#           endif
            if (!m_file.is_open()) {
                throw std::runtime_error("Failed to open log file: " + m_file_path);
            }
        }

        std::string create_file_path(int64_t date_ts) const {
            std::string date_str = time_shield::to_iso8601_date(date_ts);
            return get_directory_path() + "/" + date_str + ".log";
        }

        void write_log(const std::string& message, const int64_t& timestamp_ms) {
            const int64_t message_date_ts = time_shield::start_of_day(time_shield::ms_to_sec(timestamp_ms));
            if (message_date_ts != m_current_date_ts) {
                open_log_file(message_date_ts);
            }
            if (m_file.is_open()) {
                m_file << message << std::endl;
            }
            remove_old_logs();
        }

        void remove_old_logs() {
            const int64_t threshold_ts = m_current_date_ts - (time_shield::SEC_PER_DAY * m_config.auto_delete_days);
#           if __cplusplus >= 201703L
#           ifdef _WIN32
            fs::path dir_path = fs::u8path(get_directory_path());
#           else
            fs::path dir_path(get_directory_path());
#           endif
 
            if (!fs::exists(dir_path) ||
                !fs::is_directory(dir_path)) {
                return;
            }
 
            for (const auto& entry : fs::directory_iterator(dir_path)) {
                if (!fs::is_regular_file(entry.status())) continue;
                std::string filename = entry.path().filename().string();
                if (is_valid_log_filename(filename)) {
                    const int64_t file_date_ts = get_date_ts_from_filename(filename);
                    if (file_date_ts < threshold_ts) {
                        fs::remove(entry.path());
                    }
                }
            }
#           else
            std::vector<std::string> file_list = get_list_files(get_directory_path());
            for (const auto& file_path : file_list) {
                // Extract the file name
                std::string filename = file_path.substr(file_path.find_last_of("/\\") + 1);
                if (is_valid_log_filename(filename)) {
                    const int64_t file_date_ts = get_date_ts_from_filename(filename);
                    if (file_date_ts < threshold_ts) {
#                       if defined(_WIN32)
                        remove(utf8_to_ansi(file_path).c_str());
#                       else
                        remove(file_path.c_str());
#                       endif
                    }
                }
            }
#           endif
        }

        bool is_valid_log_filename(const std::string& filename) const {
            static const std::regex pattern(R"((\d{4}-\d{2}-\d{2})\.log)");
            return std::regex_match(filename, pattern);
        }

        int64_t get_date_ts_from_filename(const std::string& filename) const {
            constexpr size_t EXTENSION_LENGTH = sizeof(".log") - 1;
            return time_shield::ts(filename.substr(0, filename.size() - EXTENSION_LENGTH));
        }

        int64_t get_current_utc_date_ts() const {
            return time_shield::start_of_day(time_shield::ms_to_sec(current_timestamp_ms()));
        }

        int64_t current_timestamp_ms() const {
            return LOGIT_CURRENT_TIMESTAMP_MS();
        }

        std::string get_last_log_file_path() const {
            std::lock_guard<std::mutex> lock(m_file_path_mutex);
            return m_file_path;
        }

        std::string get_last_log_file_name() const {
            std::lock_guard<std::mutex> lock(m_file_path_mutex);
            return m_file_name;
        }

        int64_t get_last_log_ts() const {
            return m_last_log_ts;
        }

    int64_t get_time_since_last_log() const {
        return LOGIT_CURRENT_TIMESTAMP_MS() - m_last_log_ts;
    }
    }; // FileLogger
#endif // defined(__EMSCRIPTEN__)
 
}; // namespace logit
 
#endif // _LOGIT_FILE_LOGGER_HPP_INCLUDED