AsyncLogger Class Reference

#include <async_logger.hpp>

Public Member Functions
void	log_block (const std::string &msg)
void	flush ()
void	stop ()

Static Public Member Functions
static AsyncLogger &	instance ()

Private Member Functions
	AsyncLogger ()
	~AsyncLogger ()

Static Private Member Functions
static std::string	timestamp ()

Private Attributes
std::thread	worker_
std::queue< std::string >	queue_
std::mutex	mtx_
std::condition_variable	cv_
std::string	log_path_
std::atomic< bool >	stop_ {false}

Detailed Description

Definition at line 33 of file async_logger.hpp.

Constructor & Destructor Documentation

AsyncLogger()

AsyncLogger::AsyncLogger ( )

inlineprivate

Definition at line 67 of file async_logger.hpp.

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

References cv_, log_path_, mtx_, queue_, stop_, and worker_.

Referenced by instance().

~AsyncLogger()

AsyncLogger::~AsyncLogger ( )

inlineprivate

Definition at line 107 of file async_logger.hpp.

                   {
        stop();
    }

References stop().

Member Function Documentation

flush()

void AsyncLogger::flush ( )

inline

Definition at line 51 of file async_logger.hpp.

                 {
        std::unique_lock<std::mutex> lock(mtx_);
        cv_.notify_one();
    }

References cv_, and mtx_.

instance()

AsyncLogger & AsyncLogger::instance ( )

inlinestatic

Definition at line 35 of file async_logger.hpp.

                                   {
        static AsyncLogger inst;
        return inst;
    }

References AsyncLogger().

log_block()

void AsyncLogger::log_block ( const std::string & msg )

inline

Definition at line 40 of file async_logger.hpp.

                                         {
        if (stop_.load(std::memory_order_acquire))
            return;
 
        {
            std::lock_guard<std::mutex> lock(mtx_);
            queue_.push(timestamp() + " " + msg);
        }
        cv_.notify_one();
    }

References cv_, mtx_, queue_, stop_, and timestamp().

stop()

void AsyncLogger::stop ( )

inline

Definition at line 56 of file async_logger.hpp.

                {
        bool expected = false;
        if (!stop_.compare_exchange_strong(expected, true))
            return; // già fermato
 
        cv_.notify_one();
        if (worker_.joinable())
            worker_.join();
    }

References cv_, stop_, and worker_.

Referenced by ~AsyncLogger().

timestamp()

std::string AsyncLogger::timestamp ( )

inlinestaticprivate

Definition at line 111 of file async_logger.hpp.

                                 {
        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;
    }

Referenced by log_block().

Member Data Documentation

cv_

std::condition_variable AsyncLogger::cv_

private

Definition at line 125 of file async_logger.hpp.

Referenced by AsyncLogger(), flush(), log_block(), and stop().

log_path_

std::string AsyncLogger::log_path_

private

Definition at line 126 of file async_logger.hpp.

Referenced by AsyncLogger().

mtx_

std::mutex AsyncLogger::mtx_

private

Definition at line 124 of file async_logger.hpp.

Referenced by AsyncLogger(), flush(), and log_block().

queue_

std::queue<std::string> AsyncLogger::queue_

private

Definition at line 123 of file async_logger.hpp.

Referenced by AsyncLogger(), and log_block().

stop_

std::atomic<bool> AsyncLogger::stop_ {false}

private

Definition at line 127 of file async_logger.hpp.

Referenced by AsyncLogger(), log_block(), and stop().

worker_

std::thread AsyncLogger::worker_

private

Definition at line 122 of file async_logger.hpp.

Referenced by AsyncLogger(), and stop().

---

The documentation for this class was generated from the following file:

• BastionGuard/src/phishing/async_logger.hpp