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 <utility>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#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;
            uint64_t    max_file_size_bytes = 0;
            uint32_t    max_rotated_files   = 0;
            bool        compress_rotated    = false;
            std::string compress_cmd;
        };
 
        FileLogger() { warn(); }
        FileLogger(const Config&) { warn(); }
        FileLogger(const std::string&, const bool& = true, const int& = 30,
                    const uint64_t& = 0, const uint32_t& = 0,
                    const bool& = false, std::string = {}) { 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;     
            uint64_t    max_file_size_bytes = 0;   
            uint32_t    max_rotated_files   = 0;   
            bool        compress_rotated    = false; 
            std::string compress_cmd;             
        };

        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();
        }

        FileLogger(
                const std::string& directory,
                const bool& async,
                const int& auto_delete_days,
                uint64_t max_file_size_bytes,
                uint32_t max_rotated_files,
                bool compress_rotated = false,
                std::string compress_cmd = {}) {
            m_config.directory = directory;
            m_config.async = async;
            m_config.auto_delete_days = auto_delete_days;
            m_config.max_file_size_bytes = max_file_size_bytes;
            m_config.max_rotated_files = max_rotated_files;
            m_config.compress_rotated = compress_rotated;
            m_config.compress_cmd = std::move(compress_cmd);
            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;
            detail::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;
            detail::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; 
        uint64_t           m_current_file_size = 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);
            }
            m_file.seekp(0, std::ios::end);
            m_current_file_size = static_cast<uint64_t>(m_file.tellp());
        }

        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_config.max_file_size_bytes > 0) {
                const uint64_t add = static_cast<uint64_t>(message.size() + 1);
                if (m_current_file_size + add > m_config.max_file_size_bytes) {
                    rotate_current_file();
                }
            }
            if (m_file.is_open()) {
                m_file << message << std::endl;
                m_current_file_size += static_cast<uint64_t>(message.size() + 1);
            }
            remove_old_logs();
        }
 
        void rotate_current_file() {
            if (m_file.is_open()) m_file.close();
 
            const std::string base = time_shield::to_iso8601_date(m_current_date_ts);
            const std::string dir  = get_directory_path();
            const std::string cur  = dir + "/" + base + ".log";
            std::string rotated;
            uint32_t idx = 1;
#           if __cplusplus >= 201703L
            for (;; ++idx) {
                rotated = dir + "/" + base + "." + std::to_string(idx) + ".log";
                if (!fs::exists(rotated)) break;
            }
#           else
            auto file_exists = [](const std::string& path) {
#               if defined(_WIN32)
                std::ifstream f(utf8_to_ansi(path).c_str());
#               else
                std::ifstream f(path.c_str());
#               endif
                return f.good();
            };
            for (;; ++idx) {
                rotated = dir + "/" + base + "." + std::to_string(idx) + ".log";
                if (!file_exists(rotated)) break;
            }
#           endif
#           if defined(_WIN32)
            std::rename(utf8_to_ansi(cur).c_str(), utf8_to_ansi(rotated).c_str());
#           else
            std::rename(cur.c_str(), rotated.c_str());
#           endif
 
            if (m_config.compress_rotated && !m_config.compress_cmd.empty()) {
                std::string cmd = m_config.compress_cmd;
                size_t pos = cmd.find("{file}");
                if (pos != std::string::npos) cmd.replace(pos, 6, "\"" + rotated + "\"");
                std::system(cmd.c_str());
            }
 
            if (m_config.max_rotated_files > 0) {
                enforce_rotation_retention(base, m_config.max_rotated_files, dir);
            }
 
            open_log_file(m_current_date_ts);
            m_current_file_size = 0;
        }
 
        void enforce_rotation_retention(const std::string& base, uint32_t max_files, const std::string& dir) {
#           if __cplusplus >= 201703L
            std::vector<std::pair<uint32_t, fs::path>> files;
            std::regex pattern(base + R"(\.(\d+)\.log(\..*)?)");
            for (const auto& entry : fs::directory_iterator(dir)) {
                if (!fs::is_regular_file(entry.status())) continue;
                std::smatch m;
                std::string name = entry.path().filename().string();
                if (std::regex_match(name, m, pattern)) {
                    uint32_t idx = static_cast<uint32_t>(std::stoul(m[1].str()));
                    files.emplace_back(idx, entry.path());
                }
            }
            if (files.size() <= max_files) return;
            std::sort(files.begin(), files.end(), [](const std::pair<uint32_t, fs::path>& a, const std::pair<uint32_t, fs::path>& b) { return a.first < b.first; });
            size_t to_remove = files.size() - max_files;
            for (size_t i = 0; i < to_remove; ++i) {
                fs::remove(files[i].second);
            }
#           else
            std::vector<std::pair<uint32_t, std::string>> files;
            std::regex pattern(base + R"(\.(\d+)\.log(\..*)?)");
            std::vector<std::string> file_list = get_list_files(dir);
            for (const auto& path : file_list) {
                std::string name = path.substr(path.find_last_of("/\\") + 1);
                std::smatch m;
                if (std::regex_match(name, m, pattern)) {
                    uint32_t idx = static_cast<uint32_t>(std::stoul(m[1].str()));
                    files.emplace_back(idx, path);
                }
            }
            if (files.size() <= max_files) return;
            std::sort(files.begin(), files.end(), [](const std::pair<uint32_t, std::string>& a, const std::pair<uint32_t, std::string>& b) { return a.first < b.first; });
            size_t to_remove = files.size() - max_files;
            for (size_t i = 0; i < to_remove; ++i) {
#               if defined(_WIN32)
                remove(utf8_to_ansi(files[i].second).c_str());
#               else
                remove(files[i].second.c_str());
#               endif
            }
#           endif
        }

        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 {
            return filename.size() >= 10 && filename[4] == '-' && filename[7] == '-';
        }

        int64_t get_date_ts_from_filename(const std::string& filename) const {
            return time_shield::ts(filename.substr(0, 10));
        }

        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