Adapter to use thread_system's monitoring capabilities. More...

#include <thread_system_monitor_adapter.h>

Inheritance diagram for kcenon::logger::thread_system_monitor_adapter:

Collaboration diagram for kcenon::logger::thread_system_monitor_adapter:

Public Member Functions
	thread_system_monitor_adapter (kcenon::thread::monitorable_interface *monitorable)
	Constructor with external monitorable.

	thread_system_monitor_adapter ()
	Default constructor with fallback to basic monitor.

	~thread_system_monitor_adapter () override
	Destructor.

result< monitoring_data >	collect_metrics () const override
	Collect current metrics.

result< health_check_result >	check_health () const override
	Perform health check.

common::VoidResult	reset_metrics () override
	Reset all metrics.

common::VoidResult	set_enabled (bool enable) override
	Enable or disable monitoring.

bool	is_enabled () const override
	Check if monitoring is enabled.

std::string	get_backend_name () const override
	Get backend name.

void	increment_counter (const std::string &name, double value=1.0) override
	Increment a counter.

void	update_gauge (const std::string &name, double value) override
	Update a gauge.

void	record_histogram (const std::string &name, double value) override
	Record a histogram value.

void	set_monitorable (kcenon::thread::monitorable_interface *monitorable, bool take_ownership=false)
	Set the thread_system monitorable.

basic_monitor *	get_fallback_monitor ()
	Get the fallback monitor for direct access.

Public Member Functions inherited from kcenon::logger::monitoring_interface
virtual	~monitoring_interface ()=default
	Virtual destructor.

Private Attributes
kcenon::thread::monitorable_interface *	monitorable_

std::unique_ptr< basic_monitor >	fallback_monitor_

bool	owns_monitorable_

std::atomic< bool >	enabled_ {true}

Detailed Description

Adapter to use thread_system's monitoring capabilities.

This adapter wraps thread_system's monitorable_interface to provide compatibility with our monitoring interface, enabling advanced monitoring features when thread_system is available.

Definition at line 32 of file thread_system_monitor_adapter.h.

Constructor & Destructor Documentation

◆ thread_system_monitor_adapter() [1/2]

kcenon::logger::thread_system_monitor_adapter::thread_system_monitor_adapter ( kcenon::thread::monitorable_interface * monitorable )

inlineexplicit

Constructor with external monitorable.

Parameters

monitorable Pointer to existing monitorable interface

Definition at line 44 of file thread_system_monitor_adapter.h.

        : monitorable_(monitorable), 
          fallback_monitor_(std::make_unique<basic_monitor>()),
          owns_monitorable_(false) {
        if (!monitorable_) {
            throw std::invalid_argument("Monitorable cannot be null");
        }
    }

References monitorable_.

◆ thread_system_monitor_adapter() [2/2]

kcenon::logger::thread_system_monitor_adapter::thread_system_monitor_adapter ( )

inline

Default constructor with fallback to basic monitor.

Definition at line 57 of file thread_system_monitor_adapter.h.

        : monitorable_(nullptr),
          fallback_monitor_(std::make_unique<basic_monitor>()),
          owns_monitorable_(false) {}

◆ ~thread_system_monitor_adapter()

kcenon::logger::thread_system_monitor_adapter::~thread_system_monitor_adapter ( )

inlineoverride

Destructor.

Definition at line 65 of file thread_system_monitor_adapter.h.

                                              {
        if (owns_monitorable_ && monitorable_) {
            delete monitorable_;
        }
    }

References monitorable_, and owns_monitorable_.

Member Function Documentation

◆ check_health()

result< health_check_result > kcenon::logger::thread_system_monitor_adapter::check_health ( ) const

inlineoverridevirtual

Perform health check.

Returns: Result containing health check result

Implements kcenon::logger::monitoring_interface.

Definition at line 123 of file thread_system_monitor_adapter.h.

                                                              {
        health_check_result result;
        
        // Check thread_system health if available
        if (monitorable_) {
            try {
                auto ts_health = monitorable_->get_health_status();
                if (ts_health) {
                    // Convert thread_system health to our format
                    auto status = ts_health.value();
                    
                    if (!status.is_healthy()) {
                        result.set_status(health_status::degraded);
                        result.add_issue("Thread system reports unhealthy status");
                        
                        for (const auto& issue : status.get_issues()) {
                            result.add_issue("Thread system: " + issue);
                        }
                    }
                }
            } catch (...) {
                result.add_issue("Failed to check thread_system health");
            }
        }
        
        // Also check fallback monitor for logger-specific health
        if (fallback_monitor_) {
            auto fallback_health = fallback_monitor_->check_health();
            if (fallback_health) {
                auto& fb_result = fallback_health.value();
                
                // Merge health status
                if (!fb_result.is_healthy()) {
                    if (result.get_status() == health_status::healthy) {
                        result.set_status(fb_result.get_status());
                    } else if (fb_result.get_status() == health_status::unhealthy) {
                        result.set_status(health_status::unhealthy);
                    }
                    
                    // Add logger-specific issues
                    for (const auto& issue : fb_result.get_issues()) {
                        result.add_issue(issue);
                    }
                }
            }
        }
        
        // Set overall message
        if (result.is_healthy()) {
            result.set_message("All systems operational");
        } else {
            result.set_message("Issues detected in monitoring");
        }
        
        return result;
    }

References fallback_monitor_, and monitorable_.

◆ collect_metrics()

result< monitoring_data > kcenon::logger::thread_system_monitor_adapter::collect_metrics ( ) const

inlineoverridevirtual

Collect current metrics.

Returns: Result containing monitoring data

Implements kcenon::logger::monitoring_interface.

Definition at line 75 of file thread_system_monitor_adapter.h.

                                                             {
        if (!enabled_.load()) {
            return error_code::metrics_not_available;
        }
        
        // Try thread_system first
        if (monitorable_) {
            try {
                auto ts_metrics = monitorable_->get_metrics();
                if (ts_metrics) {
                    // Convert thread_system metrics to our format
                    monitoring_data data;
                    
                    // Extract metrics from thread_system monitoring_data
                    // Note: This assumes thread_system has similar metric structure
                    for (const auto& [key, value] : ts_metrics.value().get_values()) {
                        data.add_metric(key, value);
                    }
                    
                    // Also add fallback monitor metrics for logger-specific data
                    if (fallback_monitor_) {
                        auto fallback_result = fallback_monitor_->collect_metrics();
                        if (fallback_result) {
                            for (const auto& metric : fallback_result.value().get_metrics()) {
                                data.add_metric(metric);
                            }
                        }
                    }
                    
                    return data;
                }
            } catch (...) {
                // Fall through to fallback
            }
        }
        
        // Fallback to basic monitor
        if (fallback_monitor_) {
            return fallback_monitor_->collect_metrics();
        }
        
        return error_code::metrics_not_available;
    }

References kcenon::logger::monitoring_data::add_metric(), enabled_, fallback_monitor_, kcenon::logger::metrics_not_available, and monitorable_.

Here is the call graph for this function:

◆ get_backend_name()

std::string kcenon::logger::thread_system_monitor_adapter::get_backend_name ( ) const

inlineoverridevirtual

Get backend name.

Returns: "thread_system" or "thread_system+basic"

Implements kcenon::logger::monitoring_interface.

Definition at line 237 of file thread_system_monitor_adapter.h.

                                                {
        if (monitorable_) {
            return "thread_system+basic";
        }
        return "basic(via adapter)";
    }

References monitorable_.

◆ get_fallback_monitor()

basic_monitor * kcenon::logger::thread_system_monitor_adapter::get_fallback_monitor ( )

inline

Get the fallback monitor for direct access.

Returns: Pointer to fallback monitor

Definition at line 323 of file thread_system_monitor_adapter.h.

                                          {
        return fallback_monitor_.get();
    }

References fallback_monitor_.

◆ increment_counter()

void kcenon::logger::thread_system_monitor_adapter::increment_counter	(	const std::string &	name,
		double	value = 1.0 )

inlineoverridevirtual

Increment a counter.

Parameters

name	Counter name
value	Increment value

Implements kcenon::logger::monitoring_interface.

Definition at line 249 of file thread_system_monitor_adapter.h.

                                                                               {
        if (!enabled_.load()) return;
        
        // Always use fallback for logger-specific counters
        if (fallback_monitor_) {
            fallback_monitor_->increment_counter(name, value);
        }
        
        // Also update thread_system if it supports this
        if (monitorable_) {
            try {
                monitorable_->update_metric(name, value);
            } catch (...) {
                // Ignore failures
            }
        }
    }

References enabled_, fallback_monitor_, and monitorable_.

◆ is_enabled()

bool kcenon::logger::thread_system_monitor_adapter::is_enabled ( ) const

inlineoverridevirtual

Check if monitoring is enabled.

Returns: true if enabled

Implements kcenon::logger::monitoring_interface.

Definition at line 229 of file thread_system_monitor_adapter.h.

                                     {
        return enabled_.load();
    }

References enabled_.

◆ record_histogram()

void kcenon::logger::thread_system_monitor_adapter::record_histogram	(	const std::string &	name,
		double	value )

inlineoverridevirtual

Record a histogram value.

Parameters

name	Histogram name
value	Value to record

Implements kcenon::logger::monitoring_interface.

Definition at line 295 of file thread_system_monitor_adapter.h.

                                                                        {
        if (!enabled_.load()) return;
        
        // Always use fallback for histograms
        if (fallback_monitor_) {
            fallback_monitor_->record_histogram(name, value);
        }
    }

References enabled_, and fallback_monitor_.

◆ reset_metrics()

common::VoidResult kcenon::logger::thread_system_monitor_adapter::reset_metrics ( )

inlineoverridevirtual

Reset all metrics.

Returns: Result indicating success

Implements kcenon::logger::monitoring_interface.

Definition at line 184 of file thread_system_monitor_adapter.h.

                                              {
        common::VoidResult result = common::ok();
 
        // Reset thread_system metrics if available
        if (monitorable_) {
            try {
                auto ts_result = monitorable_->reset_metrics();
                if (ts_result.is_err()) {
                    result = make_logger_void_result(logger_error_code::operation_failed);
                }
            } catch (...) {
                result = make_logger_void_result(logger_error_code::operation_failed);
            }
        }
 
        // Reset fallback monitor
        if (fallback_monitor_) {
            auto fb_result = fallback_monitor_->reset_metrics();
            if (fb_result.is_err() && result.is_ok()) {
                result = fb_result;
            }
        }
 
        return result;
    }

References fallback_monitor_, kcenon::logger::make_logger_void_result(), monitorable_, kcenon::common::ok(), and kcenon::logger::operation_failed.

Here is the call graph for this function:

◆ set_enabled()

common::VoidResult kcenon::logger::thread_system_monitor_adapter::set_enabled ( bool enable )

inlineoverridevirtual

Enable or disable monitoring.

Parameters

enable true to enable

Returns: Result indicating success

Implements kcenon::logger::monitoring_interface.

Definition at line 215 of file thread_system_monitor_adapter.h.

                                                       {
        enabled_ = enable;
 
        if (fallback_monitor_) {
            fallback_monitor_->set_enabled(enable);
        }
 
        return common::ok();
    }

References enabled_, fallback_monitor_, and kcenon::common::ok().

Here is the call graph for this function:

◆ set_monitorable()

void kcenon::logger::thread_system_monitor_adapter::set_monitorable	(	kcenon::thread::monitorable_interface *	monitorable,
		bool	take_ownership = false )

inline

Set the thread_system monitorable.

Parameters

monitorable	Pointer to monitorable interface
take_ownership	Whether to take ownership

Definition at line 309 of file thread_system_monitor_adapter.h.

                                                     {
        if (owns_monitorable_ && monitorable_) {
            delete monitorable_;
        }
        
        monitorable_ = monitorable;
        owns_monitorable_ = take_ownership;
    }

References monitorable_, and owns_monitorable_.

◆ update_gauge()

void kcenon::logger::thread_system_monitor_adapter::update_gauge	(	const std::string &	name,
		double	value )

inlineoverridevirtual

Update a gauge.

Parameters

name	Gauge name
value	New value

Implements kcenon::logger::monitoring_interface.

Definition at line 272 of file thread_system_monitor_adapter.h.

                                                                    {
        if (!enabled_.load()) return;
        
        // Always use fallback for logger-specific gauges
        if (fallback_monitor_) {
            fallback_monitor_->update_gauge(name, value);
        }
        
        // Also update thread_system if it supports this
        if (monitorable_) {
            try {
                monitorable_->update_metric(name, value);
            } catch (...) {
                // Ignore failures
            }
        }
    }