async_logger.hpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#pragma once
#include <fstream>
#include <string>
#include <mutex>
#include <queue>
#include <thread>
#include <chrono>
#include <condition_variable>
#include <filesystem>
#include <iostream>
#include <atomic>
 
class AsyncLogger {
public:
    static AsyncLogger& instance() {
        static AsyncLogger inst;
        return inst;
    }
 
    void log_block(const std::string& msg) {
        if (stop_.load(std::memory_order_acquire))
            return;
 
        {
            std::lock_guard<std::mutex> lock(mtx_);
            queue_.push(timestamp() + " " + msg);
        }
        cv_.notify_one();
    }
 
    void flush() {
        std::unique_lock<std::mutex> lock(mtx_);
        cv_.notify_one();
    }
 
    void stop() {
        bool expected = false;
        if (!stop_.compare_exchange_strong(expected, true))
            return; // già fermato
 
        cv_.notify_one();
        if (worker_.joinable())
            worker_.join();
    }
 
private:
    AsyncLogger() {
        try {
            std::filesystem::create_directories("/var/log/BastionGuard");
        } catch (...) {
        }
 
        log_path_ = "/var/log/BastionGuard/phishing_scanner.log";
        stop_.store(false, std::memory_order_release);
 
        worker_ = std::thread([this]() {
            std::unique_lock<std::mutex> lock(mtx_);
            while (true) {
                cv_.wait(lock, [this]() {
                    return !queue_.empty() || stop_.load(std::memory_order_acquire);
                });
 
                if (stop_.load(std::memory_order_acquire) && queue_.empty())
                    break;
 
                std::queue<std::string> local_queue;
                std::swap(local_queue, queue_);
                lock.unlock();
 
                try {
                    std::ofstream fout(log_path_, std::ios::app | std::ios::binary);
                    if (fout.is_open()) {
                        while (!local_queue.empty()) {
                            fout << local_queue.front() << '\n';
                            local_queue.pop();
                        }
                        fout.flush();
                    }
                } catch (...) {
                }
 
                lock.lock();
            }
        });
    }
 
    ~AsyncLogger() {
        stop();
    }
 
    static std::string timestamp() {
        using namespace std::chrono;
        auto now = system_clock::now();
        std::time_t t = system_clock::to_time_t(now);
        std::tm tm_buf{};
        localtime_r(&t, &tm_buf);
        char buf[64];
        std::strftime(buf, sizeof(buf), "[%Y-%m-%d %H:%M:%S]", &tm_buf);
        return buf;
    }
 
    std::thread worker_;
    std::queue<std::string> queue_;
    std::mutex mtx_;
    std::condition_variable cv_;
    std::string log_path_;
    std::atomic<bool> stop_{false};
};