AsyncLogger.h

#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <sstream>

class AsyncLogger {
public:
    AsyncLogger() : exitFlag(false), queueFullWarningShown(false) {
        worker = std::thread([this] {
            processQueue();
        });
    }

    ~AsyncLogger() {
        {
            std::lock_guard<std::mutex> lock(queueMutex);
            exitFlag = true;
        }
        cv.notify_one();
        if (worker.joinable()) {
            worker.join();
        }
    }

    void log(const std::string& message) {
        {
            std::lock_guard<std::mutex> lock(queueMutex);
            if (msgQueue.size() >= MAX_QUEUE_SIZE) {
                if (!queueFullWarningShown) {
                    std::cerr << "[Security] AsyncLogger queue full (" << MAX_QUEUE_SIZE
                              << " messages). Dropping logs to prevent DoS.\n";
                    queueFullWarningShown = true;
                }
                return;
            }
            msgQueue.push(message);
        }
        cv.notify_one();
    }

private:
    const size_t MAX_QUEUE_SIZE = 10000;
    std::thread worker;
    std::queue<std::string> msgQueue;
    std::mutex queueMutex;
    std::condition_variable cv;
    bool exitFlag;
    bool queueFullWarningShown;

    void processQueue() {
        while (true) {
            std::unique_lock<std::mutex> lock(queueMutex);
            cv.wait(lock, [this] { return !msgQueue.empty() || exitFlag; });

            if (exitFlag && msgQueue.empty()) {
                break;
            }

            // Process all messages in the queue to minimize locking
            while (!msgQueue.empty()) {
                std::string msg = std::move(msgQueue.front());
                msgQueue.pop();

                // Unlock while doing I/O
                lock.unlock();
                std::cout << msg << std::flush;
                lock.lock();
            }

            // Reset warning flag when queue is empty
            if (msgQueue.empty()) {
                queueFullWarningShown = false;
            }
        }
    }
};