UniqueFileLogger.hpp

Go to the documentation of this file.

#ifndef _LOGIT_UNIQUE_FILE_LOGGER_HPP_INCLUDED
#define _LOGIT_UNIQUE_FILE_LOGGER_HPP_INCLUDED

 
#include "ILogger.hpp"
#include <iostream>
#include <fstream>
#include <mutex>
#include <atomic>
#include <regex>
#include <queue>
#include <functional>
#include <sstream>
#include <iomanip>
#include <ctime>
#include <random>
#include <algorithm>
#include <unordered_map>
 
namespace logit {
 
#if defined(__EMSCRIPTEN__)
 
    class UniqueFileLogger : public ILogger {
    public:
        struct Config {
            std::string directory = "unique_logs";
            bool        async     = false;
            int         auto_delete_days = 30;
            size_t      hash_length = 8;
        };
 
        UniqueFileLogger() { warn(); }
        UniqueFileLogger(const Config&) { warn(); }
        UniqueFileLogger(const std::string&, bool = true, int = 30, size_t = 8) { 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 << "UniqueFileLogger 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 UniqueFileLogger : public ILogger {
    public:

        struct Config {
            std::string directory           = "unique_logs"; 
            bool        async               = true; 
            int         auto_delete_days    = 30;   
            size_t      hash_length         = 8;    
        };

        UniqueFileLogger() {
            start_logging();
        }

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

        UniqueFileLogger(
            const std::string& directory,
            bool async = true,
            int auto_delete_days = 30,
            size_t hash_length = 8) {
            m_config.directory = directory;
            m_config.async = async;
            m_config.auto_delete_days = auto_delete_days;
            m_config.hash_length = hash_length;
            start_logging();
        }
 
        virtual ~UniqueFileLogger() {
            stop_logging();
        }

        void log(const LogRecord& record, const std::string& message) override {
            auto thread_id = record.thread_id;
            m_last_log_ts = record.timestamp_ms;
            if (!m_config.async) {
                std::lock_guard<std::mutex> lock(m_mutex);
                std::string file_path;
                try {
                    file_path = write_log(message, record.timestamp_ms);
                } catch (const std::exception& e) {
                    file_path.clear();
                    std::cerr << "Log error: " << e.what() << std::endl;
                }
 
                std::unique_lock<std::mutex> info_lock(m_thread_log_info_mutex);
                auto it = m_thread_log_info.find(thread_id);
                if (it == m_thread_log_info.end()) {
                    if (!file_path.empty()) {
                        m_thread_log_info[thread_id] = {0, file_path, get_file_name(file_path)};
                    } else {
                        m_thread_log_info[thread_id] = {0, "Not available", "Not available"};
                    }
                    return;
                }
 
                if (!file_path.empty()) {
                    it->second.last_file_path = file_path;
                    it->second.last_file_name = get_file_name(file_path);
                } else {
                    it->second.last_file_path = "Not available";
                    it->second.last_file_name = "Not available";
                }
 
                m_pending_logs_cv.notify_all();
                info_lock.unlock();
 
                try {
                    remove_old_logs();
                } catch (const std::exception& e) {
                    std::cerr << "Log error: " << e.what() << std::endl;
                }
                return;
            }
 
            std::unique_lock<std::mutex> info_lock(m_thread_log_info_mutex);
            m_thread_log_info[thread_id].pending_logs++;
            info_lock.unlock();
 
            auto timestamp_ms = record.timestamp_ms;
            TaskExecutor::get_instance().add_task([this, message, timestamp_ms, thread_id]() {
                std::lock_guard<std::mutex> lock(m_mutex);
                std::string file_path;
                try {
                    file_path = write_log(message, timestamp_ms);
                } catch (const std::exception& e) {
                    file_path.clear();
                    std::cerr << "Async log error: " << e.what() << std::endl;
                }
 
                std::unique_lock<std::mutex> info_lock(m_thread_log_info_mutex);
                auto it = m_thread_log_info.find(thread_id);
                if (it == m_thread_log_info.end()) return;
 
                if (!file_path.empty()) {
                    it->second.last_file_path = file_path;
                    it->second.last_file_name = get_file_name(file_path);
                } else {
                    it->second.last_file_path = "Not available";
                    it->second.last_file_name = "Not available";
                }
                it->second.pending_logs--;
 
                if (it->second.pending_logs == 0) {
                    m_pending_logs_cv.notify_all();
                }
                info_lock.unlock();
 
                try {
                    remove_old_logs();
                } catch (const std::exception& e) {
                    std::cerr << "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;   
 
        struct ThreadLogInfo {
            int pending_logs;
            std::string last_file_path;
            std::string last_file_name;
 
            ThreadLogInfo() : pending_logs(0) {}
 
            ThreadLogInfo(
                    const int pending_logs,
                    const std::string last_file_path,
                    const std::string last_file_name) :
                pending_logs(pending_logs),
                last_file_path(last_file_path),
                last_file_name(last_file_name) {
            }
        };
 
        mutable std::mutex m_thread_log_info_mutex; 
        mutable std::condition_variable m_pending_logs_cv; 
        std::unordered_map<std::thread::id, ThreadLogInfo> m_thread_log_info; 
 
        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() {
            std::lock_guard<std::mutex> lock(m_mutex);
            try {
                initialize_directory();
                remove_old_logs();
            } catch (const std::exception& e) {
                std::cerr << "Initialization error: " << e.what() << std::endl;
            }
        }

        void stop_logging() {
            wait();
        }

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

        std::string get_directory_path() const {
            return get_exec_dir() + "/" + m_config.directory;
        }

        std::string write_log(const std::string& message, const int64_t& timestamp_ms) {
            std::string file_path = create_unique_file_path(timestamp_ms);
#           if defined(_WIN32)
            std::ofstream file(utf8_to_ansi(file_path), std::ios_base::binary);
#           else
            std::ofstream file(file_path, std::ios_base::binary);
#           endif
            if (!file.is_open()) {
                throw std::runtime_error("Failed to open log file: " + file_path);
            }
            file.write(message.data(), message.size());
            file.close();
            return file_path;
        }

        std::string create_unique_file_path(const int64_t& timestamp_ms) const {
            const std::string timestamp_str = format_timestamp(timestamp_ms);
            const std::string hash_str = generate_fixed_length_hash(m_config.hash_length);
            return get_directory_path() + "/" + timestamp_str + "-" + hash_str + ".log";
        }

        std::string format_timestamp(const int64_t& timestamp_ms) const {
            const auto dt = time_shield::to_date_time_ms<time_shield::DateTimeStruct>(timestamp_ms);
            char buffer[32] = {0};
            snprintf(buffer, sizeof(buffer), "%lld-%.2d-%.2d_%.2d-%.2d-%.2d-%.3d", dt.year, dt.mon, dt.day, dt.hour, dt.min, dt.sec, dt.ms);
            return std::string(buffer);
        }

        std::string generate_fixed_length_hash(size_t length) const {
            static const char charset[] =
                "0123456789"
                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                "abcdefghijklmnopqrstuvwxyz";
            static thread_local std::mt19937 generator(std::random_device{}());
            static thread_local std::uniform_int_distribution<size_t> distribution(0, sizeof(charset) - 2);
 
            std::string hash;
            hash.reserve(length);
            for (size_t i = 0; i < length; ++i) {
                hash += charset[distribution(generator)];
            }
            return hash;
        }

        void remove_old_logs() {
            const int64_t threshold_ts =
                time_shield::ms_to_sec(current_timestamp_ms()) -
                (m_config.auto_delete_days * time_shield::SEC_PER_DAY);
#           if __cplusplus >= 201703L
 
#           if defined(_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_ts = get_timestamp_from_filename(filename);
                    if (file_ts < threshold_ts) {
                        fs::remove(entry.path());
                    }
                }
            }
#           else
            const std::vector<std::string> file_list = get_list_files(get_directory_path());
            for (const auto& file_path : file_list) {
                std::string filename = get_file_name(file_path);
                if (is_valid_log_filename(filename)) {
                    const int64_t file_ts = get_timestamp_from_filename(filename);
                    if (file_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}_\d{2}-\d{2}-\d{2}-\d{3})-[a-zA-Z0-9]{1,}\.log)");
            return std::regex_match(filename, pattern);
        }

        int64_t get_timestamp_from_filename(const std::string& filename) const {
            std::string datetime_str = filename.substr(0, 10); // "YYYY-MM-DD"
            return time_shield::ts(datetime_str);
        }

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

        std::string get_last_log_file_name() const {
            auto thread_id = std::this_thread::get_id();
            std::unique_lock<std::mutex> lock(m_thread_log_info_mutex);
            m_pending_logs_cv.wait(lock, [this, thread_id]() {
                auto it = m_thread_log_info.find(thread_id);
                return it == m_thread_log_info.end() || it->second.pending_logs == 0;
            });
            auto it = m_thread_log_info.find(thread_id);
            if (it != m_thread_log_info.end()) {
                return it->second.last_file_name;
            }
            return std::string();
        }

        std::string get_last_log_file_path() const {
            auto thread_id = std::this_thread::get_id();
            std::unique_lock<std::mutex> lock(m_thread_log_info_mutex);
            m_pending_logs_cv.wait(lock, [this, thread_id]() {
                auto it = m_thread_log_info.find(thread_id);
                return it == m_thread_log_info.end() || it->second.pending_logs == 0;
            });
            auto it = m_thread_log_info.find(thread_id);
            if (it != m_thread_log_info.end()) {
                return it->second.last_file_path;
            }
            return std::string();
        }

        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;
        }
 
 
    }; // UniqueFileLogger
 
#endif // defined(__EMSCRIPTEN__)
 
}; // namespace logit
 
#endif // _LOGIT_UNIQUE_FILE_LOGGER_HPP_INCLUDED