Aggregating monitor that collects metrics from multiple sources. More...

Inheritance diagram for aggregating_monitor:

Collaboration diagram for aggregating_monitor:

Public Member Functions
void	register_component (std::shared_ptr< ci::IMonitorable > component)

kcenon::common::VoidResult	record_metric (const std::string &name, double value) override

kcenon::common::VoidResult	record_metric (const std::string &name, double value, const std::unordered_map< std::string, std::string > &tags) override

kcenon::common::Result< ci::metrics_snapshot >	get_metrics () override

kcenon::common::Result< ci::health_check_result >	check_health () override

kcenon::common::VoidResult	reset () override

std::shared_ptr< ci::IMonitor >	get_monitor () override

std::shared_ptr< ci::IMonitor >	create_monitor (const std::string &name) override

size_t	get_component_count () const

Private Attributes
std::vector< std::shared_ptr< ci::IMonitorable > >	monitored_components_

std::unordered_map< std::string, double >	aggregated_metrics_

std::mutex	mutex_

Detailed Description

Aggregating monitor that collects metrics from multiple sources.

Examples: monitoring_integration_example.cpp.

Definition at line 32 of file monitoring_integration_example.cpp.

Member Function Documentation

◆ check_health()

kcenon::common::Result< ci::health_check_result > aggregating_monitor::check_health ( )

inlineoverride

Examples: monitoring_integration_example.cpp.

Definition at line 97 of file monitoring_integration_example.cpp.

                                                                      {
        std::lock_guard<std::mutex> lock(mutex_);
 
        ci::health_check_result result;
        result.timestamp = std::chrono::system_clock::now();
        result.status = ci::health_status::healthy;
        result.message = "Aggregating monitor operational";
 
        // Check health of all components
        for (const auto& component : monitored_components_) {
            auto comp_health = component->health_check();
            const auto component_name = component->get_component_name();
 
            if (kcenon::common::is_ok(comp_health)) {
                const auto& component_result = kcenon::common::get_value(comp_health);
                result.metadata["component_status:" + component_name] = ci::to_string(component_result.status);
 
                if (component_result.status == ci::health_status::unhealthy) {
                    result.status = ci::health_status::unhealthy;
                    result.message = "One or more components unhealthy";
                } else if (component_result.status == ci::health_status::degraded &&
                           result.status == ci::health_status::healthy) {
                    result.status = ci::health_status::degraded;
                    result.message = "One or more components degraded";
                }
            } else {
                const auto& error = kcenon::common::get_error(comp_health);
                result.metadata["component_status:" + component_name] = "error:" + error.message;
                if (result.status == ci::health_status::healthy) {
                    result.status = ci::health_status::degraded;
                    result.message = "Component health check failed";
                }
            }
        }
 
        return kcenon::common::Result<ci::health_check_result>::ok(std::move(result));
    }

References kcenon::common::get_error(), kcenon::common::get_value(), kcenon::common::is_ok(), monitored_components_, and mutex_.

Here is the call graph for this function:

◆ create_monitor()

std::shared_ptr< ci::IMonitor > aggregating_monitor::create_monitor ( const std::string & name )

inlineoverride

Examples: monitoring_integration_example.cpp.

Definition at line 146 of file monitoring_integration_example.cpp.

                                                                             {
        // For this example, return self
        return shared_from_this();
    }

◆ get_component_count()

size_t aggregating_monitor::get_component_count ( ) const

inline

Examples: monitoring_integration_example.cpp.

Definition at line 151 of file monitoring_integration_example.cpp.

                                       {
        std::lock_guard<std::mutex> lock(mutex_);
        return monitored_components_.size();
    }

References monitored_components_, and mutex_.

◆ get_metrics()

kcenon::common::Result< ci::metrics_snapshot > aggregating_monitor::get_metrics ( )

inlineoverride

Examples: monitoring_integration_example.cpp.

Definition at line 69 of file monitoring_integration_example.cpp.

                                                                  {
        std::lock_guard<std::mutex> lock(mutex_);
 
        ci::metrics_snapshot snapshot;
        snapshot.source_id = "aggregating_monitor";
        snapshot.capture_time = std::chrono::system_clock::now();
 
        // Add own metrics
        for (const auto& [name, value] : aggregated_metrics_) {
            snapshot.add_metric(name, value);
        }
 
        // Collect metrics from all registered components
        for (const auto& component : monitored_components_) {
            auto comp_data = component->get_monitoring_data();
            if (kcenon::common::is_ok(comp_data)) {
                const auto& component_metrics = kcenon::common::get_value(comp_data);
                for (const auto& metric : component_metrics.metrics) {
                    snapshot.metrics.push_back(metric);
                }
            } else {
                snapshot.add_metric("component_error_" + component->get_component_name(), 1.0);
            }
        }
 
        return kcenon::common::Result<ci::metrics_snapshot>::ok(std::move(snapshot));
    }

References aggregated_metrics_, kcenon::common::get_value(), kcenon::common::is_ok(), monitored_components_, and mutex_.

Here is the call graph for this function:

◆ get_monitor()

std::shared_ptr< ci::IMonitor > aggregating_monitor::get_monitor ( )

inlineoverride

Examples: monitoring_integration_example.cpp.

Definition at line 142 of file monitoring_integration_example.cpp.

                                                     {
        return shared_from_this();
    }

◆ record_metric() [1/2]

kcenon::common::VoidResult aggregating_monitor::record_metric	(	const std::string &	name,
		double	value )

inlineoverride

Examples: monitoring_integration_example.cpp.

Definition at line 48 of file monitoring_integration_example.cpp.

    {
        std::lock_guard<std::mutex> lock(mutex_);
        aggregated_metrics_[name] = value;
        return kcenon::common::ok();
    }

References aggregated_metrics_, mutex_, and kcenon::common::ok().

Referenced by record_metric().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ record_metric() [2/2]

kcenon::common::VoidResult aggregating_monitor::record_metric	(	const std::string &	name,
		double	value,
		const std::unordered_map< std::string, std::string > &	tags )

inlineoverride

Definition at line 57 of file monitoring_integration_example.cpp.

    {
        std::string tagged_name = name;
        for (const auto& [k, v] : tags) {
            tagged_name += "." + k + ":" + v;
        }
        return record_metric(tagged_name, value);
    }

References record_metric().

Here is the call graph for this function:

◆ register_component()

void aggregating_monitor::register_component ( std::shared_ptr< ci::IMonitorable > component )

inline

Examples: monitoring_integration_example.cpp.

Definition at line 41 of file monitoring_integration_example.cpp.

                                                                     {
        std::lock_guard<std::mutex> lock(mutex_);
        monitored_components_.push_back(component);
        std::cout << "[AggregatingMonitor] Registered component: "
                  << component->get_component_name() << std::endl;
    }

References monitored_components_, and mutex_.

◆ reset()

kcenon::common::VoidResult aggregating_monitor::reset ( )

inlineoverride

Examples: monitoring_integration_example.cpp.

Definition at line 135 of file monitoring_integration_example.cpp.

                                            {
        std::lock_guard<std::mutex> lock(mutex_);
        aggregated_metrics_.clear();
        return kcenon::common::ok();
    }