log.hpp

Go to the documentation of this file.

#pragma once
 
#ifndef SQLOG_H
#define SQLOG_H
 
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <ctime>
#include <cstdarg>
#include <mutex>
#include <format>
#include <thread>
#include <queue>
#include <condition_variable>
#include <filesystem>
 
#ifdef _DEBUG
#include "ename.c.inc"
#endif
 
#ifdef _WIN32
#include <windows.h>
#include <direct.h>
#define mkdir(path, mode) _mkdir(path)
#else
#include <unistd.h>
#include <sys/stat.h>
#endif
 
#define SQLOGD_BUF_SIZE 4096 
#define RESOURCE_PATH "./output" 
 
namespace utils {

inline std::mutex log_mutex;
inline std::queue<std::string> log_queue;
inline std::condition_variable log_cv;
inline bool log_thread_running = true;

inline std::string getTimeString() {
    char buffer[20];
    std::time_t now = std::time(nullptr);
    std::tm tm;
#ifdef _WIN32
    localtime_s(&tm, &now);
#else
    localtime_r(&now, &tm);
#endif
    std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tm);
    return std::string(buffer);
}

inline void ensureDirectoryExists(const std::string& dirPath) {
    std::error_code ec;
    std::filesystem::create_directories(dirPath, ec);
    if (ec) {
        std::cerr << "[LOGGER] Directory create failed: " << dirPath << " - " << ec.message() << std::endl;
    }
}

inline std::string getLogFilePath(const std::string& level) {
    ensureDirectoryExists(RESOURCE_PATH);
    return std::string(RESOURCE_PATH) + "/" + level + ".log";
}

inline void logThreadFunc() {
    while (log_thread_running) {
        std::unique_lock<std::mutex> lock(log_mutex);
        log_cv.wait(lock, [] { return !log_queue.empty() || !log_thread_running; });
 
        while (!log_queue.empty()) {
            std::string log_entry = log_queue.front();
            log_queue.pop();
            lock.unlock();
 
            std::string level = log_entry.substr(1, log_entry.find(']') - 1);
            std::ofstream log_file(getLogFilePath(level), std::ios::app);
            if (log_file.is_open()) {
                log_file << log_entry;
            }
 
            lock.lock();
        }
    }
}

inline std::thread log_thread(logThreadFunc);

inline void COUT_(const std::string& log_level, const std::string& function, int line, const char* format_str, ...) {
    char buf[SQLOGD_BUF_SIZE];
    va_list args;
    va_start(args, format_str);
    vsnprintf(buf, SQLOGD_BUF_SIZE, format_str, args);
    va_end(args);
 
    std::ostringstream logMsg;
 
#ifdef _DEBUG
    if (log_level == "ERROR" || log_level == "FATAL") {
        int err = errno;
        if (err > 0 && err < MAX_ENAME && ename[err][0] != '\0') {
            std::ostringstream err_info;
            err_info << " | errno=" << err << " (" << ename[err] << ")";
            strncat(buf, err_info.str().c_str(), SQLOGD_BUF_SIZE - strlen(buf) - 1);
        }
    }
#endif
 
#ifdef _DEBUG
    logMsg << "[" << log_level << "] [" << getTimeString() << "] (" << function << ":" << line << ") - " << buf << "\n";
#else
    logMsg << "[" << log_level << "] [" << getTimeString() << "] - " << buf << "\n";
#endif
 
#ifdef _DEBUG
    {
        std::lock_guard<std::mutex> lock(log_mutex);
        log_queue.push(logMsg.str());
    }
    log_cv.notify_one();
#endif
 
#ifdef _WIN32
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    if (log_level == "ERROR") SetConsoleTextAttribute(hConsole, 12);
    else if (log_level == "FATAL") SetConsoleTextAttribute(hConsole, 206);
    else if (log_level == "WARN")  SetConsoleTextAttribute(hConsole, 14);
    else if (log_level == "INFO")  SetConsoleTextAttribute(hConsole, 10);
    else SetConsoleTextAttribute(hConsole, 7);
#endif
 
    std::cout << logMsg.str();
 
#ifdef _WIN32
    SetConsoleTextAttribute(hConsole, 7);
#endif
 
    if (log_level == "FATAL") {
        std::exit(EXIT_FAILURE);
    }
}

inline void stopLogThread() {
    log_thread_running = false;
    log_cv.notify_all();
    if (log_thread.joinable()) log_thread.join();
}
 
} // namespace utils
 
// 로그 매크로 정의
#define SQLOG_I(format_str, ...) ::utils::COUT_("INFO",  __func__, __LINE__, format_str, ##__VA_ARGS__)         //< @brief INFO 레벨 로그
#define SQLOG_E(format_str, ...) ::utils::COUT_("ERROR", __func__, __LINE__, format_str, ##__VA_ARGS__)         //< @brief ERROR 레벨 로그
#define SQLOG_F(format_str, ...) ::utils::COUT_("FATAL", __func__, __LINE__, format_str, ##__VA_ARGS__)         //< @brief FATAL 레벨 로그 (종료)
#define SQLOG_D(format_str, ...) ::utils::COUT_("DEBUG", __func__, __LINE__, format_str, ##__VA_ARGS__)         //< @brief DEBUG 레벨 로그 (디버그 모드 전용)
#define SQLOG_W(format_str, ...) ::utils::COUT_("WARN",  __func__, __LINE__, format_str, ##__VA_ARGS__)         //< @brief WARN 레벨 로그
 
#endif // SQLOG_H // end of Logger