#include <thread_to_monitoring_adapter.h>

Collaboration diagram for kcenon::monitoring::thread_to_monitoring_adapter:

Classes
struct	collection_config

Public Member Functions
	thread_to_monitoring_adapter (std::shared_ptr< event_bus > bus)

bool	is_thread_system_available () const

common::Result< std::vector< metric > >	collect_metrics ()

std::vector< std::string >	get_metric_types () const

common::VoidResult	start_collection (const collection_config &cfg)

common::VoidResult	stop_collection ()

	~thread_to_monitoring_adapter ()

Private Attributes
std::shared_ptr< event_bus >	bus_

std::atomic< bool >	running_ {false}

std::thread	worker_

Detailed Description

Examples: event_bus_example.cpp.

Definition at line 60 of file thread_to_monitoring_adapter.h.

Constructor & Destructor Documentation

◆ thread_to_monitoring_adapter()

kcenon::monitoring::thread_to_monitoring_adapter::thread_to_monitoring_adapter ( std::shared_ptr< event_bus > bus )

inlineexplicit

Definition at line 67 of file thread_to_monitoring_adapter.h.

68 : bus_(std::move(bus)) {}

kcenon::monitoring::thread_to_monitoring_adapter::bus_

std::shared_ptr< event_bus > bus_

Definition thread_to_monitoring_adapter.h:172

◆ ~thread_to_monitoring_adapter()

kcenon::monitoring::thread_to_monitoring_adapter::~thread_to_monitoring_adapter ( )

inline

Definition at line 169 of file thread_to_monitoring_adapter.h.

169{ (void)stop_collection(); }

kcenon::monitoring::thread_to_monitoring_adapter::stop_collection

common::VoidResult stop_collection()

Definition thread_to_monitoring_adapter.h:159

References stop_collection().

Here is the call graph for this function:

Member Function Documentation

◆ collect_metrics()

common::Result< std::vector< metric > > kcenon::monitoring::thread_to_monitoring_adapter::collect_metrics ( )

inline

Definition at line 93 of file thread_to_monitoring_adapter.h.

                                                      {
        std::vector<metric> out;
 
#if MONITORING_THREAD_SYSTEM_AVAILABLE && defined(MONITORING_HAS_COMMON_INTERFACES)
        try {
            auto& container = kcenon::thread::service_container::global();
            auto monitorable = container.resolve<kcenon::common::interfaces::IMonitorable>();
            if (monitorable) {
                // Convert minimal subset of thread_system metrics into adapter metrics
                // thread_system v3.0 uses common::interfaces::IMonitorable
                auto monitoring_result = monitorable->get_monitoring_data();
                if (!monitoring_result.is_err()) {
                    const auto& snap = monitoring_result.value();
                    // Map metrics from common_system snapshot
                    for (const auto& m : snap.metrics) {
                        metric adapted{m.name, m.value, {}};
                        out.emplace_back(std::move(adapted));
                    }
                }
            }
        } catch (...) {
            // Fall back to empty on any failure
        }
#endif
 
        return common::ok(std::move(out));
    }

References kcenon::monitoring::container.

Referenced by start_collection(), and TEST_F().

Here is the caller graph for this function:

◆ get_metric_types()

std::vector< std::string > kcenon::monitoring::thread_to_monitoring_adapter::get_metric_types ( ) const

inline

Definition at line 122 of file thread_to_monitoring_adapter.h.

                                                  {
#if MONITORING_THREAD_SYSTEM_AVAILABLE
        return {
            "thread.pool.jobs_pending",
            "thread.pool.jobs_completed",
            "thread.pool.worker_threads"
        };
#else
        return {};
#endif
    }

Referenced by TEST_F().

Here is the caller graph for this function:

◆ is_thread_system_available()

bool kcenon::monitoring::thread_to_monitoring_adapter::is_thread_system_available ( ) const

inline

Examples: event_bus_example.cpp.

Definition at line 72 of file thread_to_monitoring_adapter.h.

                                            {
#if MONITORING_THREAD_SYSTEM_AVAILABLE
        // thread_system v3.0+ uses common_system interfaces
#  if defined(MONITORING_HAS_COMMON_INTERFACES)
        // Dynamic discovery via service_container if present
        try {
            auto& container = kcenon::thread::service_container::global();
            auto monitorable = container.resolve<kcenon::common::interfaces::IMonitorable>();
            return static_cast<bool>(monitorable);
        } catch (...) {
            return true; // Headers present; treat as available even if not registered
        }
#  else
        return true; // thread_system available but no common interfaces
#  endif
#else
        return false;
#endif
    }

References kcenon::monitoring::container.

Referenced by main(), and TEST_F().

Here is the caller graph for this function:

◆ start_collection()

common::VoidResult kcenon::monitoring::thread_to_monitoring_adapter::start_collection ( const collection_config & cfg )

inline

Examples: event_bus_example.cpp.

Definition at line 136 of file thread_to_monitoring_adapter.h.

                                                                    {
        if (running_.exchange(true)) {
            return common::ok(); // already running
        }
 
        if (!bus_) {
            running_ = false;
            return common::VoidResult::err(static_cast<int>(monitoring_error_code::operation_failed), "event_bus not set");
        }
 
        worker_ = std::thread([this, cfg]() {
            while (running_.load()) {
                auto res = collect_metrics();
                if (res.is_ok() && cfg.publish_events && !res.value().empty()) {
                    bus_->publish_event(metric_collection_event("thread_system_adapter", res.value()));
                }
                std::this_thread::sleep_for(cfg.interval);
            }
        });
 
        return common::ok();
    }

References bus_, collect_metrics(), kcenon::monitoring::thread_to_monitoring_adapter::collection_config::interval, kcenon::monitoring::operation_failed, kcenon::monitoring::thread_to_monitoring_adapter::collection_config::publish_events, running_, and worker_.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop_collection()

common::VoidResult kcenon::monitoring::thread_to_monitoring_adapter::stop_collection ( )

inline

Examples: event_bus_example.cpp.

Definition at line 159 of file thread_to_monitoring_adapter.h.

                                       {
        if (!running_.exchange(false)) {
            return common::ok();
        }
        if (worker_.joinable()) {
            worker_.join();
        }
        return common::ok();
    }