thread_logger.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <string>
#include <string_view>
#include <chrono>
#include <sstream>
#include <iomanip>
#include <thread>
#include <mutex>
#include <iostream>
#include <atomic>
#include <cstdlib>
#include <ctime>
 
namespace kcenon::thread {
 
enum class log_level {
    trace,
    debug,
    info,
    warning,
    error,
    critical
};
 
class thread_logger {
public:
    static thread_logger& instance() {
        // Intentionally leak to avoid static destruction order issues
        // Logger may be accessed during other singletons' destruction
        static thread_logger* logger = []() {
            auto* ptr = new thread_logger();
            // Note: atexit handler is registered early by thread_logger_init.cpp
            // We register here as well for safety (multiple calls to atexit with
            // the same function are safe per C++ standard - they just add multiple
            // entries, and prepare_shutdown() is idempotent)
            std::atexit(prepare_shutdown);
            return ptr;
        }();
        return *logger;
    }
 
    static void prepare_shutdown() {
        is_shutting_down_.store(true, std::memory_order_release);
    }
 
    static bool is_shutting_down() {
        return is_shutting_down_.load(std::memory_order_acquire);
    }
 
    [[deprecated(
        "Use 'common::interfaces::ILogger' via thread_context instead. "
        "Will be removed in v2.0.")]]
    void set_enabled(bool enabled) {
        enabled_ = enabled;
    }
 
    [[deprecated(
        "Use 'thread_context::has_logger()' instead. "
        "Will be removed in v2.0.")]]
    bool is_enabled() const {
        return enabled_;
    }
 
    [[deprecated(
        "Configure log level on 'common::interfaces::ILogger' instead. "
        "Will be removed in v2.0.")]]
    void set_level(log_level level) {
        min_level_ = level;
    }
 
    [[deprecated(
        "Use 'thread_context::log()' with 'common::interfaces::ILogger' "
        "instead. Will be removed in v2.0.")]]
    void log(log_level level, std::string_view thread_name,
             std::string_view message, std::string_view context = "") {
        // Early return during shutdown to avoid accessing potentially destroyed resources
        if (is_shutting_down_.load(std::memory_order_acquire)) {
            return;
        }
 
        if (!enabled_ || level < min_level_) {
            return;
        }
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto now = std::chrono::system_clock::now();
        auto time_t_val = std::chrono::system_clock::to_time_t(now);
        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
            now.time_since_epoch()) % 1000;
 
        // Use thread-safe localtime variant
        std::tm tm_buf{};
#if defined(_MSC_VER) || defined(_WIN32)
        localtime_s(&tm_buf, &time_t_val);
#else
        localtime_r(&time_t_val, &tm_buf);
#endif
 
        std::cerr << "["
                  << std::put_time(&tm_buf, "%Y-%m-%d %H:%M:%S")
                  << "." << std::setfill('0') << std::setw(3) << ms.count()
                  << "] "
                  << "[" << level_to_string(level) << "] "
                  << "[Thread:" << thread_name << "] "
                  << "[TID:" << std::this_thread::get_id() << "] "
                  << message;
 
        if (!context.empty()) {
            std::cerr << " | Context: " << context;
        }
 
        std::cerr << std::endl;
    }
 
    template<typename ErrorType>
    [[deprecated(
        "Use 'thread_context::log()' with 'common::interfaces::ILogger' "
        "instead. Will be removed in v2.0.")]]
    void log_error(std::string_view thread_name, const ErrorType& error) {
        // Early return during shutdown
        if (is_shutting_down_.load(std::memory_order_acquire) || !enabled_) {
            return;
        }
 
        std::ostringstream oss;
        oss << "Error code: " << error.code()
            << ", Message: " << error.message();
 
        log(log_level::error, thread_name, oss.str());
    }
 
private:
    // Static shutdown flag - checked before any logging operation
    // Uses inline to allow definition in header (C++17)
    static inline std::atomic<bool> is_shutting_down_{false};
 
    thread_logger() = default;
    ~thread_logger() = default;
    thread_logger(const thread_logger&) = delete;
    thread_logger& operator=(const thread_logger&) = delete;
 
    static const char* level_to_string(log_level level) {
        switch (level) {
            case log_level::trace: return "TRACE";
            case log_level::debug: return "DEBUG";
            case log_level::info: return "INFO";
            case log_level::warning: return "WARN";
            case log_level::error: return "ERROR";
            case log_level::critical: return "CRITICAL";
            default: return "UNKNOWN";
        }
    }
 
    // Default to warning level to minimize overhead in production
    // Use set_level(log_level::info) or set_level(log_level::debug) for verbose logging
    bool enabled_ = true;
    log_level min_level_ = log_level::warning;
    std::mutex mutex_;
 
    // Lightweight mode: disable structured logging entirely
    // When enabled, logging becomes a no-op with minimal overhead
    bool lightweight_mode_ = false;
 
public:
    [[deprecated(
        "Use a null 'common::interfaces::ILogger' in thread_context to "
        "disable logging. Will be removed in v2.0.")]]
    void set_lightweight_mode(bool enabled) {
        lightweight_mode_ = enabled;
        // Disable logging when in lightweight mode
        if (enabled) {
            enabled_ = false;
        }
    }
 
    [[deprecated(
        "Superseded by 'common::interfaces::ILogger' injection. "
        "Will be removed in v2.0.")]]
    bool is_lightweight_mode() const {
        return lightweight_mode_;
    }
};
 
} // namespace kcenon::thread