thread_context.h

Go to the documentation of this file.

 
#pragma once
 
// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#include <memory>
#include <optional>
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/global_logger_registry.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
#include "service_container.h"
#include <kcenon/thread/core/log_level.h>
#include <kcenon/thread/core/thread_logger.h>
 
namespace kcenon::thread {
 
// Type alias for common_system ILogger
using ILogger = common::interfaces::ILogger;
 
// Type alias for common_system IMonitor
using IMonitor = common::interfaces::IMonitor;
 
class thread_context {
public:
    thread_context()
        : logger_(common::interfaces::GlobalLoggerRegistry::instance().get_default_logger())
        , monitoring_(service_container::global().resolve<common::interfaces::IMonitor>()) {
    }
 
    explicit thread_context(
        std::shared_ptr<ILogger> logger,
        std::shared_ptr<IMonitor> monitoring = nullptr)
        : logger_(std::move(logger))
        , monitoring_(std::move(monitoring)) {
    }
 
    std::shared_ptr<ILogger> logger() const {
        return logger_;
    }
 
    std::shared_ptr<IMonitor> monitoring() const {
        return monitoring_;
    }
 
    void log(common::interfaces::log_level level, const std::string& message) const {
        // Skip logging during static destruction to prevent SDOF
        if (thread_logger::is_shutting_down()) {
            return;
        }
        if (logger_) {
            logger_->log(level, message);
        }
    }
 
    void log(log_level_v2 level, const std::string& message) const {
        // Skip logging during static destruction to prevent SDOF
        if (thread_logger::is_shutting_down()) {
            return;
        }
        if (logger_) {
            logger_->log(to_common_level(level), message);
        }
    }
 
    void log(common::interfaces::log_level level,
             std::string_view message,
             const common::source_location& loc = common::source_location::current()) const {
        // Skip logging during static destruction to prevent SDOF
        if (thread_logger::is_shutting_down()) {
            return;
        }
        if (logger_) {
            logger_->log(level, message, loc);
        }
    }
 
    void update_system_metrics(const common::interfaces::system_metrics& metrics) const {
        // Skip monitoring during static destruction to prevent SDOF
        if (thread_logger::is_shutting_down()) {
            return;
        }
        if (monitoring_) {
            std::unordered_map<std::string, std::string> tags{{"component", "system"}};
            monitoring_->record_metric("cpu_usage_percent", metrics.cpu_usage_percent.value, tags);
            monitoring_->record_metric("memory_usage_bytes", metrics.memory_usage_bytes.value, tags);
            monitoring_->record_metric("active_threads", metrics.active_threads.value, tags);
            monitoring_->record_metric("total_allocations", metrics.total_allocations.value, tags);
        }
    }
 
    void update_thread_pool_metrics(const common::interfaces::thread_pool_metrics& metrics) const {
        // Skip monitoring during static destruction to prevent SDOF
        if (thread_logger::is_shutting_down()) {
            return;
        }
        if (monitoring_) {
            std::unordered_map<std::string, std::string> tags{
                {"component", "thread_pool"},
                {"pool_name", metrics.pool_name},
                {"pool_instance_id", std::to_string(metrics.pool_instance_id)}
            };
            monitoring_->record_metric("jobs_completed", metrics.jobs_completed.value, tags);
            monitoring_->record_metric("jobs_pending", metrics.jobs_pending.value, tags);
            monitoring_->record_metric("worker_threads", metrics.worker_threads.value, tags);
            monitoring_->record_metric("idle_threads", metrics.idle_threads.value, tags);
            monitoring_->record_metric("average_latency_ns", metrics.average_latency_ns.value, tags);
            monitoring_->record_metric("total_execution_time_ns", metrics.total_execution_time_ns.value, tags);
        }
    }
 
    void update_thread_pool_metrics(const std::string& pool_name,
                                   std::uint32_t pool_instance_id,
                                   const common::interfaces::thread_pool_metrics& metrics) const {
        // Skip monitoring during static destruction to prevent SDOF
        if (thread_logger::is_shutting_down()) {
            return;
        }
        if (monitoring_) {
            std::unordered_map<std::string, std::string> tags{
                {"component", "thread_pool"},
                {"pool_name", pool_name},
                {"pool_instance_id", std::to_string(pool_instance_id)}
            };
            monitoring_->record_metric("jobs_completed", metrics.jobs_completed.value, tags);
            monitoring_->record_metric("jobs_pending", metrics.jobs_pending.value, tags);
            monitoring_->record_metric("worker_threads", metrics.worker_threads.value, tags);
            monitoring_->record_metric("idle_threads", metrics.idle_threads.value, tags);
            monitoring_->record_metric("average_latency_ns", metrics.average_latency_ns.value, tags);
            monitoring_->record_metric("total_execution_time_ns", metrics.total_execution_time_ns.value, tags);
        }
    }
 
    void update_worker_metrics(std::size_t worker_id,
                              const common::interfaces::worker_metrics& metrics) const {
        // Skip monitoring during static destruction to prevent SDOF
        if (thread_logger::is_shutting_down()) {
            return;
        }
        if (monitoring_) {
            std::unordered_map<std::string, std::string> tags{
                {"component", "worker"},
                {"worker_id", std::to_string(worker_id)}
            };
            monitoring_->record_metric("jobs_processed", metrics.jobs_processed.value, tags);
            monitoring_->record_metric("total_processing_time_ns", metrics.total_processing_time_ns.value, tags);
            monitoring_->record_metric("idle_time_ns", metrics.idle_time_ns.value, tags);
            monitoring_->record_metric("context_switches", metrics.context_switches.value, tags);
        }
    }
 
    thread_context create_child() const {
        return thread_context(logger_, monitoring_);
    }
 
    auto get_context_name() const -> std::string {
        return context_name_;
    }
 
    auto set_context_name(const std::string& name) -> bool {
        context_name_ = name;
        return true;
    }
 
    auto has_logger() const -> bool {
        return logger_ != nullptr;
    }
 
    auto has_monitoring() const -> bool {
        return monitoring_ != nullptr;
    }
 
private:
    std::shared_ptr<ILogger> logger_;
    std::shared_ptr<IMonitor> monitoring_;
    mutable std::string context_name_;
 
    static common::interfaces::log_level to_common_level(log_level_v2 level) {
        switch (level) {
            case log_level_v2::trace: return common::interfaces::log_level::trace;
            case log_level_v2::debug: return common::interfaces::log_level::debug;
            case log_level_v2::info: return common::interfaces::log_level::info;
            case log_level_v2::warn: return common::interfaces::log_level::warning;
            case log_level_v2::error: return common::interfaces::log_level::error;
            case log_level_v2::critical: return common::interfaces::log_level::critical;
            case log_level_v2::off: return common::interfaces::log_level::off;
            default: return common::interfaces::log_level::info;
        }
    }
};
 
class thread_context_builder {
public:
    thread_context_builder& with_logger(std::shared_ptr<ILogger> logger) {
        logger_ = std::move(logger);
        return *this;
    }
 
    thread_context_builder& with_monitoring(std::shared_ptr<IMonitor> monitoring) {
        monitoring_ = std::move(monitoring);
        return *this;
    }
 
    thread_context_builder& from_global_registry() {
        logger_ = common::interfaces::GlobalLoggerRegistry::instance().get_default_logger();
        monitoring_ = service_container::global().resolve<common::interfaces::IMonitor>();
        return *this;
    }
 
    thread_context build() const {
        return thread_context(logger_, monitoring_);
    }
 
private:
    std::shared_ptr<ILogger> logger_;
    std::shared_ptr<IMonitor> monitoring_;
};
 
} // namespace kcenon::thread