FileLogger.hpp

Go to the documentation of this file.

#pragma once
#ifndef LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_FILELOGGER_HPP_INCLUDED
#define LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_FILELOGGER_HPP_INCLUDED
 
 
#include "ILogger.hpp"
#include <iostream>
#include <fstream>
#include <mutex>
#include <atomic>
#include <queue>
#include <functional>
#include <utility>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <memory>
#include <sstream>
#include <iomanip>
#include <regex>
#include <time_shield/text/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;
            CompressType compress       = CompressType::NONE;
            int         compress_level  = 1;
            bool        compress_async  = true;
            std::string external_cmd;
            RotationNaming naming      = RotationNaming::Sequence;
            uint32_t    seq_width       = 3;
            bool        use_dedicated_executor = false;
            std::size_t queue_capacity = 0;
            QueuePolicy queue_policy = QueuePolicy::Block;
        };
 
        FileLogger() { warn(); }
        FileLogger(const Config&) { warn(); }
        FileLogger(const std::string&, const bool& = true, const int& = 30,
                    const uint64_t& = 0, const uint32_t& = 0) { warn(); }
        FileLogger(const std::string&, const bool&, const int&, bool, std::size_t,
                   QueuePolicy) { warn(); }
        FileLogger(const std::string&, const bool&, const int&, uint64_t, uint32_t,
                   bool, std::size_t, QueuePolicy) { 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 {
            static bool warned = false;
            if (!warned) {
                warned = true;
                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;   
            CompressType compress       = CompressType::NONE; 
            int         compress_level  = 1;       
            bool        compress_async  = true;    
            std::string external_cmd;             
            RotationNaming naming      = RotationNaming::Sequence; 
            uint32_t    seq_width       = 3;       
            bool        use_dedicated_executor = false; 
            std::size_t queue_capacity = 0;       
            QueuePolicy queue_policy = QueuePolicy::Block; 
        };
 
        FileLogger() {
            start_logging();
        }
 
        FileLogger(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);
            }
            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,
                bool use_dedicated_executor,
                std::size_t queue_capacity,
                QueuePolicy queue_policy)
            : FileLogger(make_config(
                    directory,
                    async,
                    auto_delete_days,
                    0,
                    0,
                    use_dedicated_executor,
                    queue_capacity,
                    queue_policy)) {}
 
        FileLogger(
                const std::string& directory,
                const bool& async,
                const int& auto_delete_days,
                uint64_t max_file_size_bytes,
                uint32_t max_rotated_files) {
            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;
            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 use_dedicated_executor,
                std::size_t queue_capacity,
                QueuePolicy queue_policy)
            : FileLogger(make_config(
                    directory,
                    async,
                    auto_delete_days,
                    max_file_size_bytes,
                    max_rotated_files,
                    use_dedicated_executor,
                    queue_capacity,
                    queue_policy)) {}
 
        virtual ~FileLogger() {
            shutdown();
            stop_logging();
            if (m_compressor) m_compressor->wait();
        }
 
        void set_config(const Config& config) {
            std::unique_ptr<detail::SingleThreadExecutor> old_executor;
            {
                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->wait();
                    } else {
                        detail::TaskExecutor::get_instance().wait();
                    }
                    {
                        std::lock_guard<std::mutex> lock(m_mutex);
                        if (m_file.is_open()) m_file.flush();
                    }
                }
 
                {
                    std::lock_guard<std::mutex> lock(m_mutex);
                    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;
            }
 
            std::lock_guard<std::mutex> lock(m_mutex);
 
            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;
            m_last_log_ts = record.timestamp_ms;
            m_last_log_mono_ts = LOGIT_MONOTONIC_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;
            if (m_executor) {
                m_executor->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;
                    }
                });
            } else {
                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 static_cast<double>(get_last_log_ts()) / 1000.0;
            case LoggerParam::TimeSinceLastLog:
                return static_cast<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());
        }
 
        std::vector<LogFileInfo> list_log_files() const override {
            const std::string directory = get_directory_path();
            const std::string current_file_path = get_last_log_file_path();
            std::vector<LogFileInfo> files;
 
#           if __cplusplus >= 201703L
#               if defined(_WIN32)
            fs::path dir_path = fs::u8path(directory);
#               else
            fs::path dir_path(directory);
#               endif
            if (!fs::exists(dir_path) || !fs::is_directory(dir_path)) {
                return files;
            }
 
            for (const auto& entry : fs::directory_iterator(dir_path)) {
                if (!fs::is_regular_file(entry.status())) continue;
#               if defined(_WIN32)
                const std::string file_path = entry.path().u8string();
#               else
                const std::string file_path = entry.path().string();
#               endif
                LogFileInfo info;
                if (try_make_log_file_info(file_path, current_file_path, info)) {
                    files.push_back(info);
                }
            }
#           else
            const std::vector<std::string> file_list = get_list_files(directory);
            for (size_t i = 0; i < file_list.size(); ++i) {
                LogFileInfo info;
                if (try_make_log_file_info(file_list[i], current_file_path, info)) {
                    files.push_back(info);
                }
            }
#           endif
 
            sort_log_files_newest_first(files);
            return files;
        }
 
        LogFileReadResult read_log_file(const std::string& path) const override {
            const std::vector<LogFileInfo> files = list_log_files();
            for (size_t i = 0; i < files.size(); ++i) {
                if (same_path(files[i].path, path)) {
                    return read_log_file_from_info(files[i]);
                }
            }
 
            LogFileReadResult result;
            result.file.path = path;
            result.file.name = get_file_name(path);
            result.ok = false;
            return result;
        }
 
        std::vector<LogFileReadResult> read_log_files(const std::vector<std::string>& paths) const override {
            const std::vector<LogFileInfo> files = list_log_files();
            std::vector<LogFileReadResult> results;
            results.reserve(paths.size());
 
            for (size_t i = 0; i < paths.size(); ++i) {
                bool found = false;
                for (size_t j = 0; j < files.size(); ++j) {
                    if (same_path(files[j].path, paths[i])) {
                        results.push_back(read_log_file_from_info(files[j]));
                        found = true;
                        break;
                    }
                }
 
                if (!found) {
                    LogFileReadResult result;
                    result.file.path = paths[i];
                    result.file.name = get_file_name(paths[i]);
                    result.ok = false;
                    results.push_back(result);
                }
            }
 
            return results;
        }
 
        LogClearResult clear_logs(const LogClearOptions& options = LogClearOptions()) override {
            (void)options;
            wait();
 
            std::lock_guard<std::mutex> lifecycle_lock(m_lifecycle_mutex);
            LogClearResult result;
            if (m_shutdown.load(std::memory_order_acquire)) {
                result.ok = false;
                result.status = LogClearStatus::Failed;
                result.message = "FileLogger is shut down";
                return result;
            }
 
            try {
                std::lock_guard<std::mutex> lock(m_mutex);
                const std::vector<LogFileInfo> files = list_log_files();
                if (m_file.is_open()) {
                    m_file.flush();
                    m_file.close();
                }
                for (size_t i = 0; i < files.size(); ++i) {
                    if (remove_file_path(files[i].path)) {
                        ++result.cleared_records;
                    }
                }
                m_current_file_size = 0;
                m_last_log_ts.store(0, std::memory_order_release);
                m_last_log_mono_ts.store(0, std::memory_order_release);
                open_log_file(get_current_utc_date_ts());
                result.ok = true;
                result.status = LogClearStatus::Cleared;
                result.message = "cleared";
            } catch (const std::exception& e) {
                result.ok = false;
                result.status = LogClearStatus::Failed;
                result.message = std::string("FileLogger clear error: ") + e.what();
            } catch (...) {
                result.ok = false;
                result.status = LogClearStatus::Failed;
                result.message = "FileLogger clear error";
            }
            return result;
        }
 
        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();
            }
            std::lock_guard<std::mutex> lock(m_mutex);
            if (m_file.is_open()) m_file.flush();
        }
 
        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();
                std::lock_guard<std::mutex> lock(m_mutex);
                if (m_file.is_open()) m_file.flush();
            } else if (m_config.async) {
                wait();
            }
        }
 
    private:
        mutable std::mutex m_mutex;    
        std::mutex         m_lifecycle_mutex; 
        Config             m_config;   
        mutable 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::unique_ptr<detail::CompressionWorker> m_compressor; 
        std::unique_ptr<detail::SingleThreadExecutor> m_executor; 
        std::atomic<int64_t> m_last_log_ts = ATOMIC_VAR_INIT(0); 
        std::atomic<int64_t> m_last_log_mono_ts = ATOMIC_VAR_INIT(0); 
        std::atomic<int>   m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));
        std::atomic<bool>  m_shutdown = ATOMIC_VAR_INIT(false);
 
        static Config make_config(
                const std::string& directory,
                bool async,
                int auto_delete_days,
                uint64_t max_file_size_bytes,
                uint32_t max_rotated_files,
                bool use_dedicated_executor,
                std::size_t queue_capacity,
                QueuePolicy queue_policy) {
            Config config;
            config.directory = directory;
            config.async = async;
            config.auto_delete_days = auto_delete_days;
            config.max_file_size_bytes = max_file_size_bytes;
            config.max_rotated_files = max_rotated_files;
            config.use_dedicated_executor = use_dedicated_executor;
            config.queue_capacity = queue_capacity;
            config.queue_policy = queue_policy;
            return config;
        }
 
        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";
        }
 
        bool try_make_log_file_info(
                const std::string& file_path,
                const std::string& current_file_path,
                LogFileInfo& info) const {
            if (!is_direct_child_path(file_path, get_directory_path())) {
                return false;
            }
 
            const std::string filename = get_file_name(file_path);
            if (!is_valid_log_filename(filename)) {
                return false;
            }
 
            info.is_current = same_path(file_path, current_file_path);
            info.path = info.is_current ? current_file_path : file_path;
            info.name = filename;
            info.day_start_ms = time_shield::sec_to_ms(get_date_ts_from_filename(filename));
            info.is_compressed = is_compressed_log_filename(filename);
            return true;
        }
 
        LogFileReadResult read_log_file_from_info(const LogFileInfo& info) const {
            LogFileReadResult result;
            result.file = info;
 
            if (info.is_compressed) {
                result.ok = false;
                return result;
            }
 
            if (info.is_current) {
                std::lock_guard<std::mutex> lock(m_mutex);
                if (m_file.is_open()) {
                    m_file.flush();
                }
            }
 
            result.ok = read_plain_file(info.path, result.content);
            return result;
        }
 
        bool read_plain_file(const std::string& file_path, std::string& out) const {
#           if defined(_WIN32)
            std::ifstream in(utf8_to_ansi(file_path).c_str(), std::ios_base::binary);
#           else
            std::ifstream in(file_path.c_str(), std::ios_base::binary);
#           endif
            if (!in.is_open()) {
                out.clear();
                return false;
            }
 
            std::ostringstream stream;
            stream << in.rdbuf();
            out = stream.str();
            return !in.bad();
        }
 
        bool remove_file_path(const std::string& file_path) const {
#           if defined(_WIN32)
            return std::remove(utf8_to_ansi(file_path).c_str()) == 0;
#           else
            return std::remove(file_path.c_str()) == 0;
#           endif
        }
 
        void sort_log_files_newest_first(std::vector<LogFileInfo>& files) const {
            std::sort(files.begin(), files.end(), [this](const LogFileInfo& lhs, const LogFileInfo& rhs) {
                if (lhs.day_start_ms != rhs.day_start_ms) {
                    return lhs.day_start_ms > rhs.day_start_ms;
                }
                if (lhs.is_current != rhs.is_current) {
                    return lhs.is_current && !rhs.is_current;
                }
                const FileSortKey lhs_key = make_file_sort_key(lhs);
                const FileSortKey rhs_key = make_file_sort_key(rhs);
                if (lhs_key.kind_rank != rhs_key.kind_rank) {
                    return lhs_key.kind_rank > rhs_key.kind_rank;
                }
                if (lhs_key.primary != rhs_key.primary) {
                    return lhs_key.primary > rhs_key.primary;
                }
                if (lhs_key.secondary != rhs_key.secondary) {
                    return lhs_key.secondary > rhs_key.secondary;
                }
                if (lhs_key.artifact_name == rhs_key.artifact_name &&
                    lhs.is_compressed != rhs.is_compressed) {
                    return !lhs.is_compressed && rhs.is_compressed;
                }
                if (lhs_key.artifact_name != rhs_key.artifact_name) {
                    return lhs_key.artifact_name > rhs_key.artifact_name;
                }
                return normalize_path_separators(lhs.path) > normalize_path_separators(rhs.path);
            });
        }
 
        struct FileSortKey {
            int         kind_rank = 0;
            long long   primary = 0;
            long long   secondary = 0;
            std::string artifact_name;
        };
 
        static FileSortKey make_file_sort_key(const LogFileInfo& info) {
            FileSortKey key;
            key.artifact_name = strip_compression_suffix_impl(info.name);
            const std::string& plain_name = key.artifact_name;
 
            if (plain_name.size() > 15 && plain_name[10] == '_') {
                key.kind_rank = 2;
                const std::string rest = plain_name.substr(11, plain_name.size() - 15);
                const size_t dot = rest.find('.');
                const std::string time_part = dot == std::string::npos ? rest : rest.substr(0, dot);
                key.primary = std::strtoll(time_part.c_str(), nullptr, 10);
                if (dot != std::string::npos) {
                    key.secondary = std::strtoll(rest.substr(dot + 1).c_str(), nullptr, 10);
                }
                return key;
            }
 
            if (plain_name.size() > 15 && plain_name[10] == '.') {
                key.kind_rank = 1;
                key.primary = std::strtoll(
                    plain_name.substr(11, plain_name.size() - 15).c_str(),
                    nullptr,
                    10);
            }
            return key;
        }
 
        bool is_direct_child_path(const std::string& file_path, const std::string& directory_path) const {
#           if __cplusplus >= 201703L
#               if defined(_WIN32)
            return fs::u8path(file_path).parent_path().lexically_normal() ==
                   fs::u8path(directory_path).lexically_normal();
#               else
            return fs::path(file_path).parent_path().lexically_normal() ==
                   fs::path(directory_path).lexically_normal();
#               endif
#           else
            const size_t pos = file_path.find_last_of("/\\");
            if (pos == std::string::npos) return false;
            std::string parent = file_path.substr(0, pos);
            return parent == directory_path;
#           endif
        }
 
        bool same_path(const std::string& lhs, const std::string& rhs) const {
#           if __cplusplus >= 201703L
#               if defined(_WIN32)
            return fs::u8path(lhs).lexically_normal() == fs::u8path(rhs).lexically_normal();
#               else
            return fs::path(lhs).lexically_normal() == fs::path(rhs).lexically_normal();
#               endif
#           else
            return normalize_path_separators(lhs) == normalize_path_separators(rhs);
#           endif
        }
 
        std::string normalize_path_separators(const std::string& path) const {
            std::string normalized = path;
            for (size_t i = 0; i < normalized.size(); ++i) {
                if (normalized[i] == '\\') normalized[i] = '/';
            }
            return normalized;
        }
 
        bool is_compressed_log_filename(const std::string& filename) const {
            return ends_with(filename, ".gz") || ends_with(filename, ".zst");
        }
 
        std::string strip_compression_suffix(const std::string& filename) const {
            return strip_compression_suffix_impl(filename);
        }
 
        static std::string strip_compression_suffix_impl(const std::string& filename) {
            if (ends_with_impl(filename, ".gz")) {
                return filename.substr(0, filename.size() - 3);
            }
            if (ends_with_impl(filename, ".zst")) {
                return filename.substr(0, filename.size() - 4);
            }
            return filename;
        }
 
        bool ends_with(const std::string& value, const std::string& suffix) const {
            return ends_with_impl(value, suffix);
        }
 
        static bool ends_with_impl(const std::string& value, const std::string& suffix) {
            return value.size() >= suffix.size() &&
                   value.compare(value.size() - suffix.size(), suffix.size(), suffix) == 0;
        }
 
        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 << '\n';
                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();
            std::string rotated_str;
#           if __cplusplus >= 201703L
#               if defined(_WIN32)
            fs::path cur = (fs::u8path(dir) / (base + ".log")).lexically_normal();
            fs::path rotated = fs::u8path(make_rotated_name(base, dir)).lexically_normal();
#               else
            fs::path cur = (fs::path(dir) / (base + ".log")).lexically_normal();
            fs::path rotated = fs::path(make_rotated_name(base, dir)).lexically_normal();
#               endif
            std::error_code ec;
            fs::rename(cur, rotated, ec);
            if (ec) {
                throw std::runtime_error("Failed to rename log file: " + ec.message());
            }
#               if defined(_WIN32)
            rotated_str = rotated.u8string();
#               else
            rotated_str = rotated.string();
#               endif
#           else
#               if defined(_WIN32)
            const std::string cur  = dir + "\\" + base + ".log";
#               else
            const std::string cur  = dir + "/" + base + ".log";
#               endif
            rotated_str = make_rotated_name(base, dir);
#               if defined(_WIN32)
            if (std::rename(utf8_to_ansi(cur).c_str(), utf8_to_ansi(rotated_str).c_str()) != 0) {
#               else
            if (std::rename(cur.c_str(), rotated_str.c_str()) != 0) {
#               endif
                throw std::runtime_error("Failed to rename log file");
            }
#           endif
 
            open_log_file(m_current_date_ts);
            m_current_file_size = 0;
 
            if (m_config.compress != CompressType::NONE) {
                if (m_config.compress_async) {
                    if (!m_compressor) {
                        m_compressor.reset(new detail::CompressionWorker(
                            m_config.compress, m_config.compress_level, m_config.external_cmd));
                    }
                    m_compressor->enqueue(rotated_str);
                } else {
                    detail::compress_file(m_config.compress, rotated_str, m_config.compress_level, m_config.external_cmd);
                }
            }
 
            if (m_config.max_rotated_files > 0) {
                enforce_rotation_retention(base, m_config.max_rotated_files, dir);
            }
        }
 
        void enforce_rotation_retention(const std::string& base, uint32_t max_files, const std::string& dir) {
#           if __cplusplus >= 201703L
            std::vector<fs::path> files;
            for (const auto& entry : fs::directory_iterator(dir)) {
                if (!fs::is_regular_file(entry.status())) continue;
                std::string name = entry.path().filename().string();
                if (name.rfind(base, 0) == 0 && name != base + ".log") {
                    files.emplace_back(entry.path());
                }
            }
            if (files.size() <= max_files) return;
            // Extract timestamp and optional index for chronological sorting
            auto extract = [&base](const std::string& name) {
                int64_t ts = 0;
                int      idx = 0;
                std::string rest = name.substr(base.size());
                if (!rest.empty() && (rest[0] == '_' || rest[0] == '.')) {
                    rest = rest.substr(1);
                    size_t dot = rest.find('.');
                    ts = std::strtoll(rest.substr(0, dot).c_str(), nullptr, 10);
                    if (dot != std::string::npos) {
                        size_t dot2 = rest.find('.', dot + 1);
                        if (dot2 != std::string::npos) {
                            idx = std::atoi(rest.substr(dot + 1, dot2 - dot - 1).c_str());
                        }
                    }
                }
                return std::make_pair(ts, idx);
            };
            std::sort(files.begin(), files.end(), [&](const fs::path& a, const fs::path& b) {
                auto pa = extract(a.filename().string());
                auto pb = extract(b.filename().string());
                return (pa.first == pb.first) ? (pa.second < pb.second) : (pa.first < pb.first);
            });
            size_t to_remove = files.size() - max_files;
            for (size_t i = 0; i < to_remove; ++i) {
                fs::remove(files[i]);
            }
#           else
            std::vector<std::string> files;
            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);
                if (name.rfind(base, 0) == 0 && name != base + ".log") {
                    files.emplace_back(path);
                }
            }
            if (files.size() <= max_files) return;
            // Extract timestamp and optional index for chronological sorting
            auto extract = [&base](const std::string& name) {
                int64_t ts = 0;
                int      idx = 0;
                std::string rest = name.substr(base.size());
                if (!rest.empty() && (rest[0] == '_' || rest[0] == '.')) {
                    rest = rest.substr(1);
                    size_t dot = rest.find('.');
                    ts = std::strtoll(rest.substr(0, dot).c_str(), nullptr, 10);
                    if (dot != std::string::npos) {
                        size_t dot2 = rest.find('.', dot + 1);
                        if (dot2 != std::string::npos) {
                            idx = std::atoi(rest.substr(dot + 1, dot2 - dot - 1).c_str());
                        }
                    }
                }
                return std::make_pair(ts, idx);
            };
            std::sort(files.begin(), files.end(), [&](const std::string& a, const std::string& b) {
                auto pa = extract(a.substr(a.find_last_of("/\\") + 1));
                auto pb = extract(b.substr(b.find_last_of("/\\") + 1));
                return (pa.first == pb.first) ? (pa.second < pb.second) : (pa.first < pb.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]).c_str());
#               else
                remove(files[i].c_str());
#               endif
            }
#           endif
        }
 
        std::string make_rotated_name(const std::string& base, const std::string& dir) const {
            switch (m_config.naming) {
            case RotationNaming::Sequence:
                return make_sequence_name(base, dir);
            case RotationNaming::Timestamp:
            case RotationNaming::TimestampMs:
                return make_timestamp_name(base, dir);
            }
            return make_sequence_name(base, dir);
        }
 
        std::string make_sequence_name(const std::string& base, const std::string& dir) const {
            uint32_t idx = 1;
            std::string rotated;
#           if __cplusplus >= 201703L
            for (;; ++idx) {
                std::ostringstream oss;
                oss << dir << "/" << base << '.' << std::setw(m_config.seq_width)
                    << std::setfill('0') << idx << ".log";
                rotated = oss.str();
                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) {
                std::ostringstream oss;
                oss << dir << "/" << base << '.' << std::setw(m_config.seq_width)
                    << std::setfill('0') << idx << ".log";
                rotated = oss.str();
                if (!file_exists(rotated)) break;
            }
#           endif
            return rotated;
        }
 
        std::string make_timestamp_name(const std::string& base, const std::string& dir) const {
            int64_t ts_ms = LOGIT_CURRENT_TIMESTAMP_MS();
            time_t sec = static_cast<time_t>(time_shield::ms_to_sec(ts_ms));
            std::tm tm{};
#           if defined(_WIN32)
            gmtime_s(&tm, &sec);
#           else
            gmtime_r(&sec, &tm);
#           endif
            char buf[32];
            std::strftime(buf, sizeof(buf), "%H%M%S", &tm);
            std::string timepart(buf);
            if (m_config.naming == RotationNaming::TimestampMs) {
                char msbuf[4];
                std::snprintf(msbuf, sizeof(msbuf), "%03d", static_cast<int>(ts_ms % 1000));
                timepart += msbuf;
            }
            std::string rotated = dir + "/" + base + "_" + timepart + ".log";
#           if __cplusplus >= 201703L
            if (!fs::exists(rotated)) return rotated;
            uint32_t idx = 1;
            for (;; ++idx) {
                std::string candidate = rotated.substr(0, rotated.size() - 4) + "." + std::to_string(idx) + ".log";
                if (!fs::exists(candidate)) return candidate;
            }
#           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();
            };
            if (!file_exists(rotated)) return rotated;
            uint32_t idx = 1;
            for (;; ++idx) {
                std::ostringstream oss;
                oss << rotated.substr(0, rotated.size() - 4) << '.' << idx << ".log";
                std::string candidate = oss.str();
                if (!file_exists(candidate)) return candidate;
            }
#           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 {
            const std::string plain_name = strip_compression_suffix(filename);
            static const std::regex current_pattern(R"(^\d{4}-\d{2}-\d{2}\.log$)");
            static const std::regex sequence_pattern(R"(^\d{4}-\d{2}-\d{2}\.\d+\.log$)");
            static const std::regex timestamp_pattern(R"(^\d{4}-\d{2}-\d{2}_\d{6}(\d{3})?(\.\d+)?\.log$)");
            return std::regex_match(plain_name, current_pattern) ||
                   std::regex_match(plain_name, sequence_pattern) ||
                   std::regex_match(plain_name, timestamp_pattern);
        }
 
        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_MONOTONIC_MS() - m_last_log_mono_ts;
        }
    }; // FileLogger
 
#endif // defined(__EMSCRIPTEN__)
 
}; // namespace logit
 
#endif // LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_FILELOGGER_HPP_INCLUDED