Logger.cpp

Go to the documentation of this file.

#include "../../include/public/Core/Logger.hpp"
 
#include <spdlog/async.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/spdlog.h>
 
#include <Core/OSDef.hpp>
 
#include <algorithm>
#include <chrono>
#include <ctime>
#include <filesystem>
#include <vector>
 
#ifdef PLATFORM_WIN
#include <Windows.h>
#define TRACE_COLOR FOREGROUND_BLUE | FOREGROUND_INTENSITY
#define WARN_COLOR FOREGROUND_RED | FOREGROUND_GREEN
#define ERROR_COLOR FOREGROUND_RED | FOREGROUND_INTENSITY
#define CRITIC_COLOR FOREGROUND_RED
#else
#define TRACE_COLOR "\033[0;34m"
#define WARN_COLOR "\033[33m"
#define ERROR_COLOR "\033[91m"
#define CRITIC_COLOR "\033[31m"
#endif
 
namespace Sleak {
 
std::shared_ptr<spdlog::logger> Logger::CoreLogger;
std::shared_ptr<spdlog::logger> Logger::GameLogger;
 
void Logger::Init(const std::string& ProjectName) {
    // Create the async thread pool (use 8192 queue size, 1 worker thread)
    spdlog::init_thread_pool(8192, 1);
 
    // Set up a shared console sink
    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
    console_sink->set_level(spdlog::level::trace);
    console_sink->set_color(spdlog::level::trace, TRACE_COLOR);
    console_sink->set_color(spdlog::level::warn, WARN_COLOR);
    console_sink->set_color(spdlog::level::err, ERROR_COLOR);
    console_sink->set_color(spdlog::level::critical, CRITIC_COLOR);
 
#ifdef DEBUG
    // Debug: one timestamped log per session under logs/, keep newest 10
    namespace fs = std::filesystem;
    std::error_code ec;
    fs::create_directories("logs", ec);
 
    std::vector<fs::path> sessions;
    for (auto& e : fs::directory_iterator("logs", ec))
        if (e.is_regular_file() && e.path().extension() == ".log" &&
            e.path().filename() != "latest.log")
            sessions.push_back(e.path());
    std::sort(sessions.begin(), sessions.end());
    while (sessions.size() >= 10) {
        fs::remove(sessions.front(), ec);
        sessions.erase(sessions.begin());
    }
 
    char stamp[32];
    std::time_t now = std::time(nullptr);
    std::strftime(stamp, sizeof(stamp), "%Y%m%d_%H%M%S", std::localtime(&now));
    std::string logPath = "logs/" + ProjectName + "_" + stamp + ".log";
 
    auto file_sink =
        std::make_shared<spdlog::sinks::basic_file_sink_mt>(logPath, true);
 
#ifndef PLATFORM_WIN
    // logs/latest.log always points at the current session
    fs::remove("logs/latest.log", ec);
    fs::create_symlink(fs::path(logPath).filename(), "logs/latest.log", ec);
#endif
#else
    auto file_sink =
        std::make_shared<spdlog::sinks::basic_file_sink_mt>("Engine.log", true);
#endif
 
    // Combine console + file sinks
    std::vector<spdlog::sink_ptr> sinks{console_sink, file_sink};
 
    // Create async loggers
    CoreLogger = std::make_shared<spdlog::async_logger>(
        "Sleak Engine", sinks.begin(), sinks.end(), spdlog::thread_pool());
    GameLogger = std::make_shared<spdlog::async_logger>(
        ProjectName, sinks.begin(), sinks.end(), spdlog::thread_pool());
 
    CoreLogger->set_level(spdlog::level::trace);
    GameLogger->set_level(spdlog::level::trace);
 
    // Crash-safe: errors flush immediately, everything else every second
    CoreLogger->flush_on(spdlog::level::err);
    GameLogger->flush_on(spdlog::level::err);
    spdlog::flush_every(std::chrono::seconds(1));
 
    spdlog::register_logger(CoreLogger);
    spdlog::register_logger(GameLogger);
}
 
// Static function to get the logger
std::shared_ptr<spdlog::logger>& Logger::GetCoreLogger() {
    static std::shared_ptr<spdlog::logger> CoreLoggerInstance = CoreLogger;
    return CoreLoggerInstance;
}
 
std::shared_ptr<spdlog::logger>& Logger::GetLogger() {
    static std::shared_ptr<spdlog::logger> GameLoggerInstance = GameLogger;
    return GameLoggerInstance;
}
 
}  // namespace Sleak