kcenon::thread::thread_logger Class Reference

Structured logger for thread system. More...

#include <thread_logger.h>

Collaboration diagram for kcenon::thread::thread_logger:

Public Member Functions
void	set_enabled (bool enabled)
	Enable/disable logging.
bool	is_enabled () const
	Check if logging is enabled.
void	set_level (log_level level)
	Set minimum log level.
void	log (log_level level, std::string_view thread_name, std::string_view message, std::string_view context="")
	Log a message with context.
template<typename ErrorType >
void	log_error (std::string_view thread_name, const ErrorType &error)
	Log error with error code.
void	set_lightweight_mode (bool enabled)
	Enable lightweight mode (disables all logging for maximum performance).
bool	is_lightweight_mode () const
	Check if in lightweight mode.

Static Public Member Functions
static thread_logger &	instance ()
	Get singleton instance.
static void	prepare_shutdown ()
	Prepare for process shutdown.
static bool	is_shutting_down ()
	Check if shutdown is in progress.

Private Member Functions
	thread_logger ()=default
	~thread_logger ()=default
	thread_logger (const thread_logger &)=delete
thread_logger &	operator= (const thread_logger &)=delete

Static Private Member Functions
static const char *	level_to_string (log_level level)

Private Attributes
bool	enabled_ = true
log_level	min_level_ = log_level::warning
std::mutex	mutex_
bool	lightweight_mode_ = false

Static Private Attributes
static std::atomic< bool >	is_shutting_down_ {false}

Detailed Description

Structured logger for thread system.

Provides thread-safe, structured logging with timestamps, thread IDs, and severity levels for better diagnostics.

Thread Safety:

• All methods are thread-safe
• Uses mutex for synchronized output
• Lock-free in disabled state

SDOF Prevention:

• The shutdown handler is registered early during program initialization via thread_logger_init.cpp, ensuring it runs after all user static object destructors complete (atexit handlers run in LIFO order)
• This guarantees is_shutting_down() returns true during static destruction

See also

thread_logger_init.cpp for early registration implementation

Definition at line 71 of file thread_logger.h.

Constructor & Destructor Documentation

thread_logger() [1/2]

kcenon::thread::thread_logger::thread_logger ( )

privatedefault

Referenced by instance().

Here is the caller graph for this function:

~thread_logger()

kcenon::thread::thread_logger::~thread_logger ( )

privatedefault

thread_logger() [2/2]

kcenon::thread::thread_logger::thread_logger ( const thread_logger & )

privatedelete

Member Function Documentation

instance()

static thread_logger & kcenon::thread::thread_logger::instance ( )

inlinestatic

Get singleton instance.

Uses intentional leak pattern to avoid static destruction order issues. The logger may be accessed during other singletons' destruction, so we intentionally leak to ensure it remains valid.

Note

The atexit handler for SDOF protection is registered early during program initialization by thread_logger_init.cpp, not here. This ensures the handler runs after all user static object destructors complete, guaranteeing is_shutting_down() returns true during the destruction phase.

See also

thread_logger_init.cpp

Definition at line 88 of file thread_logger.h.

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

References prepare_shutdown(), and thread_logger().

Referenced by kcenon::thread::thread_base::start().

Here is the call graph for this function:

Here is the caller graph for this function:

is_enabled()

bool kcenon::thread::thread_logger::is_enabled ( ) const

inline

Check if logging is enabled.

Deprecated

Since v1.0.0. Check availability through thread_context::has_logger() instead. Will be removed in v2.0.0.

Definition at line 144 of file thread_logger.h.

                            {
        return enabled_;
    }

References enabled_.

is_lightweight_mode()

bool kcenon::thread::thread_logger::is_lightweight_mode ( ) const

inline

Check if in lightweight mode.

Deprecated

Since v1.0.0. See set_lightweight_mode deprecation. Will be removed in v2.0.0.

Definition at line 308 of file thread_logger.h.

                                     {
        return lightweight_mode_;
    }

References lightweight_mode_.

is_shutting_down()

static bool kcenon::thread::thread_logger::is_shutting_down ( )

inlinestatic

Check if shutdown is in progress.

Definition at line 117 of file thread_logger.h.

                                   {
        return is_shutting_down_.load(std::memory_order_acquire);
    }

References is_shutting_down_.

Referenced by kcenon::thread::thread_context::log(), kcenon::thread::thread_context::log(), kcenon::thread::thread_context::log(), kcenon::thread::thread_context::update_system_metrics(), kcenon::thread::thread_context::update_thread_pool_metrics(), kcenon::thread::thread_context::update_thread_pool_metrics(), kcenon::thread::thread_context::update_worker_metrics(), and kcenon::thread::thread_pool::~thread_pool().

Here is the caller graph for this function:

level_to_string()

static const char * kcenon::thread::thread_logger::level_to_string ( log_level level )

inlinestaticprivate

Definition at line 252 of file thread_logger.h.

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

References kcenon::thread::critical, kcenon::thread::debug, kcenon::thread::error, kcenon::thread::info, kcenon::thread::trace, and kcenon::thread::warning.

Referenced by log().

Here is the caller graph for this function:

log()

void kcenon::thread::thread_logger::log ( log_level level, std::string_view thread_name, std::string_view message, std::string_view context = "" )

inline

Log a message with context.

Parameters

level	Severity level
thread_name	Thread identifier
message	Log message
context	Additional context (optional)

Deprecated

Since v1.0.0. Use thread_context::log() backed by common::interfaces::ILogger instead. Will be removed in v2.0.0.

Definition at line 176 of file thread_logger.h.

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

References enabled_, is_shutting_down_, level_to_string(), min_level_, and mutex_.

Referenced by log_error(), and kcenon::thread::thread_base::start().

Here is the call graph for this function:

Here is the caller graph for this function:

log_error()

template<typename ErrorType >

void kcenon::thread::thread_logger::log_error ( std::string_view thread_name, const ErrorType & error )

inline

Log error with error code.

Deprecated

Since v1.0.0. Use thread_context::log() with a common::interfaces::ILogger implementation instead. Will be removed in v2.0.0.

Definition at line 229 of file thread_logger.h.

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

References kcenon::thread::error::code(), enabled_, kcenon::thread::error, is_shutting_down_, log(), and kcenon::thread::error::message().

Here is the call graph for this function:

operator=()

thread_logger & kcenon::thread::thread_logger::operator= ( const thread_logger & )

privatedelete

prepare_shutdown()

static void kcenon::thread::thread_logger::prepare_shutdown ( )

inlinestatic

Prepare for process shutdown.

Call this before process termination to prevent log calls during static destruction. Once called, all log operations become no-ops.

Definition at line 110 of file thread_logger.h.

                                   {
        is_shutting_down_.store(true, std::memory_order_release);
    }

References is_shutting_down_.

Referenced by instance().

Here is the caller graph for this function:

set_enabled()

void kcenon::thread::thread_logger::set_enabled ( bool enabled )

inline

Enable/disable logging.

Deprecated

Since v1.0.0. Inject a common::interfaces::ILogger via thread_context and control logging through its implementation instead. Will be removed in v2.0.0.

Definition at line 131 of file thread_logger.h.

                                   {
        enabled_ = enabled;
    }

References enabled_.

set_level()

void kcenon::thread::thread_logger::set_level ( log_level level )

inline

Set minimum log level.

Deprecated

Since v1.0.0. Configure log level on the injected common::interfaces::ILogger implementation instead. Will be removed in v2.0.0.

Definition at line 158 of file thread_logger.h.

                                    {
        min_level_ = level;
    }

References min_level_.

set_lightweight_mode()

void kcenon::thread::thread_logger::set_lightweight_mode ( bool enabled )

inline

Enable lightweight mode (disables all logging for maximum performance).

In lightweight mode, all log calls become no-ops with minimal overhead. Useful for performance-critical production deployments where diagnostics are handled externally.

Parameters

enabled

true to enable lightweight mode, false to use normal logging

Deprecated

Since v1.0.0. With common::interfaces::ILogger, a null logger in thread_context achieves the same effect without this toggle. Will be removed in v2.0.0.

Definition at line 291 of file thread_logger.h.

                                            {
        lightweight_mode_ = enabled;
        // Disable logging when in lightweight mode
        if (enabled) {
            enabled_ = false;
        }
    }

References enabled_, and lightweight_mode_.

Member Data Documentation

enabled_

bool kcenon::thread::thread_logger::enabled_ = true

private

Definition at line 266 of file thread_logger.h.

Referenced by is_enabled(), log(), log_error(), set_enabled(), and set_lightweight_mode().

is_shutting_down_

std::atomic<bool> kcenon::thread::thread_logger::is_shutting_down_ {false}

inlinestaticprivate

Definition at line 245 of file thread_logger.h.

{false};

Referenced by is_shutting_down(), log(), log_error(), and prepare_shutdown().

lightweight_mode_

bool kcenon::thread::thread_logger::lightweight_mode_ = false

private

Definition at line 272 of file thread_logger.h.

Referenced by is_lightweight_mode(), and set_lightweight_mode().

min_level_

log_level kcenon::thread::thread_logger::min_level_ = log_level::warning

private

Definition at line 267 of file thread_logger.h.

Referenced by log(), and set_level().

mutex_

std::mutex kcenon::thread::thread_logger::mutex_

private

Definition at line 268 of file thread_logger.h.

Referenced by log().

---

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

• include/kcenon/thread/core/thread_logger.h