Central health monitoring system. More...

#include <health_monitor.h>

Collaboration diagram for kcenon::common::interfaces::health_monitor:

Public Member Functions
	health_monitor ()=default

	~health_monitor ()

	health_monitor (const health_monitor &)=delete

health_monitor &	operator= (const health_monitor &)=delete

	health_monitor (health_monitor &&)=delete

health_monitor &	operator= (health_monitor &&)=delete

Result< bool >	register_check (const std::string &name, std::shared_ptr< health_check > check)
	Register a health check.

Result< bool >	unregister_check (const std::string &name)
	Unregister a health check.

Result< health_check_result >	check (const std::string &name)
	Execute a specific health check.

Result< bool >	add_dependency (const std::string &dependent, const std::string &dependency)
	Add a dependency between health checks.

VoidResult	start ()
	Start the health monitoring.

VoidResult	stop ()
	Stop the health monitoring.

bool	is_running () const
	Check if health monitoring is running.

void	refresh ()
	Refresh all health checks.

void	register_recovery_handler (const std::string &name, recovery_handler handler)
	Register a recovery handler for a health check.

health_monitor_stats	get_stats () const
	Get monitoring statistics.

std::string	get_health_report () const
	Get a formatted health report.

health_status	get_overall_status () const
	Get the overall health status.

bool	has_check (const std::string &name) const
	Check if a health check is registered.

std::vector< std::string >	get_check_names () const
	Get all registered check names.

Private Member Functions
void	update_stats_after_check (const health_check_result &result)

void	attempt_recovery (const std::string &name)

std::string	get_overall_status_string () const

health_status	get_overall_status_internal () const

Private Attributes
health_dependency_graph	graph_

std::unordered_map< std::string, recovery_handler >	recovery_handlers_

std::unordered_map< std::string, health_check_result >	last_results_

health_monitor_stats	stats_

std::atomic< bool >	running_ {false}

std::mutex	mutex_

Detailed Description

Central health monitoring system.

This class provides a complete health monitoring solution with:

Health check registration and management
Dependency tracking between checks
Automatic health check execution
Recovery handler support
Statistics and reporting

Example usage:

health_monitor monitor;
 
// Register health checks
monitor.register_check("database", db_check);
monitor.register_check("cache", cache_check);
monitor.register_check("api", api_check);
 
// Define dependencies
monitor.add_dependency("api", "database");
monitor.add_dependency("api", "cache");
 
// Register recovery handlers
monitor.register_recovery_handler("database", []() {
    // Attempt to reconnect
    return true;
});
 
// Start monitoring
monitor.start();
 
// Get health report
std::cout << monitor.get_health_report();

Definition at line 95 of file health_monitor.h.

Constructor & Destructor Documentation

◆ health_monitor() [1/3]

kcenon::common::interfaces::health_monitor::health_monitor ( )

default

◆ ~health_monitor()

kcenon::common::interfaces::health_monitor::~health_monitor ( )

inline

Definition at line 99 of file health_monitor.h.

99{ stop().value_or(std::monostate{}); }

kcenon::common::Result::value_or

T value_or(T default_value) const

Get value or return default (C++23 std::expected compatible)

Definition core.h:384

kcenon::common::interfaces::health_monitor::stop

VoidResult stop()

Stop the health monitoring.

Definition health_monitor.h:195

References stop(), and kcenon::common::Result< T >::value_or().

Here is the call graph for this function:

◆ health_monitor() [2/3]

kcenon::common::interfaces::health_monitor::health_monitor ( const health_monitor & )

delete

◆ health_monitor() [3/3]

kcenon::common::interfaces::health_monitor::health_monitor ( health_monitor && )

delete

Member Function Documentation

◆ add_dependency()

Result< bool > kcenon::common::interfaces::health_monitor::add_dependency	(	const std::string &	dependent,
		const std::string &	dependency )

inline

Add a dependency between health checks.

Parameters

dependent	The check that depends on another
dependency	The check being depended upon

Returns: Result indicating success or failure

Definition at line 175 of file health_monitor.h.

                                                                                         {
        std::lock_guard<std::mutex> lock(mutex_);
        return graph_.add_dependency(dependent, dependency);
    }

References kcenon::common::interfaces::health_dependency_graph::add_dependency(), kcenon::common::interfaces::dependency, graph_, and mutex_.

Here is the call graph for this function:

◆ attempt_recovery()

void kcenon::common::interfaces::health_monitor::attempt_recovery ( const std::string & name )

inlineprivate

Definition at line 350 of file health_monitor.h.

                                                 {
        auto it = recovery_handlers_.find(name);
        if (it == recovery_handlers_.end()) {
            return;
        }
 
        ++stats_.recovery_attempts;
        if (it->second()) {
            ++stats_.successful_recoveries;
        }
    }

References kcenon::common::interfaces::health_monitor_stats::recovery_attempts, recovery_handlers_, stats_, and kcenon::common::interfaces::health_monitor_stats::successful_recoveries.

Referenced by check(), and refresh().

Here is the caller graph for this function:

◆ check()

Result< health_check_result > kcenon::common::interfaces::health_monitor::check ( const std::string & name )

inline

Execute a specific health check.

Parameters

name	Name of the check to execute

Returns: Result containing health check result or error

Definition at line 144 of file health_monitor.h.

                                                             {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto start_time = std::chrono::steady_clock::now();
        auto result = graph_.check_with_dependencies(name);
        auto end_time = std::chrono::steady_clock::now();
 
        if (result.is_ok()) {
            last_results_[name] = result.value();
            update_stats_after_check(result.value());
 
            stats_.last_check_time = std::chrono::system_clock::now();
            stats_.last_check_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
                end_time - start_time);
            ++stats_.check_executions;
 
            // Trigger recovery if unhealthy
            if (result.value().status == health_status::unhealthy) {
                attempt_recovery(name);
            }
        }
 
        return result;
    }

References attempt_recovery(), kcenon::common::interfaces::health_monitor_stats::check_executions, kcenon::common::interfaces::health_dependency_graph::check_with_dependencies(), graph_, kcenon::common::interfaces::health_monitor_stats::last_check_duration, kcenon::common::interfaces::health_monitor_stats::last_check_time, last_results_, mutex_, stats_, kcenon::common::interfaces::unhealthy, and update_stats_after_check().

Referenced by register_check().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_check_names()

std::vector< std::string > kcenon::common::interfaces::health_monitor::get_check_names ( ) const

inlinenodiscard

Get all registered check names.

Returns: Vector of check names

Definition at line 327 of file health_monitor.h.

                                                               {
        std::lock_guard<std::mutex> lock(mutex_);
        return graph_.get_all_nodes();
    }

References kcenon::common::interfaces::health_dependency_graph::get_all_nodes(), graph_, and mutex_.

Here is the call graph for this function:

◆ get_health_report()

std::string kcenon::common::interfaces::health_monitor::get_health_report ( ) const

inlinenodiscard

Get a formatted health report.

Returns: Human-readable health report

Definition at line 267 of file health_monitor.h.

                                                      {
        std::lock_guard<std::mutex> lock(mutex_);
 
        std::ostringstream report;
        report << "=== Health Report ===\n";
        report << "Status: " << get_overall_status_string() << "\n";
        report << "Total Checks: " << stats_.total_checks << "\n";
        report << "Healthy: " << stats_.healthy_count << "\n";
        report << "Degraded: " << stats_.degraded_count << "\n";
        report << "Unhealthy: " << stats_.unhealthy_count << "\n";
        report << "Unknown: " << stats_.unknown_count << "\n";
        report << "\n--- Individual Checks ---\n";
 
        for (const auto& [name, result] : last_results_) {
            report << name << ": " << to_string(result.status);
            if (!result.message.empty()) {
                report << " - " << result.message;
            }
            report << "\n";
        }
 
        return report.str();
    }

References kcenon::common::interfaces::health_monitor_stats::degraded_count, get_overall_status_string(), kcenon::common::interfaces::health_monitor_stats::healthy_count, last_results_, mutex_, stats_, kcenon::common::interfaces::to_string(), kcenon::common::interfaces::health_monitor_stats::total_checks, kcenon::common::interfaces::health_monitor_stats::unhealthy_count, and kcenon::common::interfaces::health_monitor_stats::unknown_count.

Here is the call graph for this function:

◆ get_overall_status()

health_status kcenon::common::interfaces::health_monitor::get_overall_status ( ) const

inlinenodiscard

Get the overall health status.

Returns: Overall health status based on all checks

Definition at line 295 of file health_monitor.h.

                                                           {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (stats_.unhealthy_count > 0) {
            return health_status::unhealthy;
        }
        if (stats_.degraded_count > 0) {
            return health_status::degraded;
        }
        if (stats_.unknown_count > 0) {
            return health_status::unknown;
        }
        if (stats_.healthy_count > 0) {
            return health_status::healthy;
        }
        return health_status::unknown;
    }

References kcenon::common::interfaces::degraded, kcenon::common::interfaces::health_monitor_stats::degraded_count, kcenon::common::interfaces::healthy, kcenon::common::interfaces::health_monitor_stats::healthy_count, mutex_, stats_, kcenon::common::interfaces::unhealthy, kcenon::common::interfaces::health_monitor_stats::unhealthy_count, kcenon::common::interfaces::unknown, and kcenon::common::interfaces::health_monitor_stats::unknown_count.

◆ get_overall_status_internal()

health_status kcenon::common::interfaces::health_monitor::get_overall_status_internal ( ) const

inlinenodiscardprivate

Definition at line 366 of file health_monitor.h.

                                                                    {
        if (stats_.unhealthy_count > 0) {
            return health_status::unhealthy;
        }
        if (stats_.degraded_count > 0) {
            return health_status::degraded;
        }
        if (stats_.unknown_count > 0) {
            return health_status::unknown;
        }
        if (stats_.healthy_count > 0) {
            return health_status::healthy;
        }
        return health_status::unknown;
    }

References kcenon::common::interfaces::degraded, kcenon::common::interfaces::health_monitor_stats::degraded_count, kcenon::common::interfaces::healthy, kcenon::common::interfaces::health_monitor_stats::healthy_count, stats_, kcenon::common::interfaces::unhealthy, kcenon::common::interfaces::health_monitor_stats::unhealthy_count, kcenon::common::interfaces::unknown, and kcenon::common::interfaces::health_monitor_stats::unknown_count.

Referenced by get_overall_status_string().

Here is the caller graph for this function:

◆ get_overall_status_string()

std::string kcenon::common::interfaces::health_monitor::get_overall_status_string ( ) const

inlinenodiscardprivate

Definition at line 362 of file health_monitor.h.

                                                              {
        return to_string(get_overall_status_internal());
    }

References get_overall_status_internal(), and kcenon::common::interfaces::to_string().

Referenced by get_health_report().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_stats()

health_monitor_stats kcenon::common::interfaces::health_monitor::get_stats ( ) const

inlinenodiscard

Get monitoring statistics.

Returns: Current statistics

Definition at line 258 of file health_monitor.h.

                                                         {
        std::lock_guard<std::mutex> lock(mutex_);
        return stats_;
    }

References mutex_, and stats_.

◆ has_check()

bool kcenon::common::interfaces::health_monitor::has_check ( const std::string & name ) const

inlinenodiscard

Check if a health check is registered.

Parameters

name	Name of the health check

Returns: true if registered

Definition at line 318 of file health_monitor.h.

                                                              {
        std::lock_guard<std::mutex> lock(mutex_);
        return graph_.has_node(name);
    }

References graph_, kcenon::common::interfaces::health_dependency_graph::has_node(), and mutex_.

Here is the call graph for this function:

◆ is_running()

bool kcenon::common::interfaces::health_monitor::is_running ( ) const

inlinenodiscard

Check if health monitoring is running.

Returns: true if running

Definition at line 206 of file health_monitor.h.

206{ return running_.load(); }

kcenon::common::interfaces::health_monitor::running_

std::atomic< bool > running_

Definition health_monitor.h:386

References running_.

◆ operator=() [1/2]

health_monitor & kcenon::common::interfaces::health_monitor::operator= ( const health_monitor & )

delete

◆ operator=() [2/2]

health_monitor & kcenon::common::interfaces::health_monitor::operator= ( health_monitor && )

delete

◆ refresh()

void kcenon::common::interfaces::health_monitor::refresh ( )

inline

Refresh all health checks.

Executes all registered health checks and updates statistics.

Definition at line 213 of file health_monitor.h.

                   {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto start_time = std::chrono::steady_clock::now();
 
        // Reset counts
        stats_.healthy_count = 0;
        stats_.degraded_count = 0;
        stats_.unhealthy_count = 0;
        stats_.unknown_count = 0;
 
        auto nodes = graph_.get_all_nodes();
        for (const auto& name : nodes) {
            auto result = graph_.check_with_dependencies(name);
            if (result.is_ok()) {
                last_results_[name] = result.value();
                update_stats_after_check(result.value());
 
                if (result.value().status == health_status::unhealthy) {
                    attempt_recovery(name);
                }
            }
        }
 
        auto end_time = std::chrono::steady_clock::now();
        stats_.last_check_time = std::chrono::system_clock::now();
        stats_.last_check_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
            end_time - start_time);
        ++stats_.check_executions;
    }

Here is the call graph for this function:

◆ register_check()

Result< bool > kcenon::common::interfaces::health_monitor::register_check	(	const std::string &	name,
		std::shared_ptr< health_check >	check )

inline

Register a health check.

Parameters

name	Unique name for this check
check	Health check implementation

Returns: Result indicating success or failure

Definition at line 112 of file health_monitor.h.

                                                                                          {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto result = graph_.add_node(name, std::move(check));
        if (result.is_ok()) {
            ++stats_.total_checks;
        }
        return result;
    }

References kcenon::common::interfaces::health_dependency_graph::add_node(), check(), graph_, mutex_, stats_, and kcenon::common::interfaces::health_monitor_stats::total_checks.

Here is the call graph for this function:

◆ register_recovery_handler()

void kcenon::common::interfaces::health_monitor::register_recovery_handler	(	const std::string &	name,
		recovery_handler	handler )

inline

Register a recovery handler for a health check.

Parameters

name	Name of the health check
handler	Recovery function to execute on failure

Definition at line 249 of file health_monitor.h.

                                                                                    {
        std::lock_guard<std::mutex> lock(mutex_);
        recovery_handlers_[name] = std::move(handler);
    }

References mutex_, and recovery_handlers_.

◆ start()

VoidResult kcenon::common::interfaces::health_monitor::start ( )

inline

Start the health monitoring.

Returns: Result indicating success or failure

Definition at line 184 of file health_monitor.h.

                       {
        if (running_.exchange(true)) {
            return {error_info{1, "Health monitor is already running", "health_monitor"}};
        }
        return ok(std::monostate{});
    }

References kcenon::common::ok(), and running_.

Here is the call graph for this function:

◆ stop()

VoidResult kcenon::common::interfaces::health_monitor::stop ( )

inline

Stop the health monitoring.

Returns: Result indicating success or failure

Definition at line 195 of file health_monitor.h.

                      {
        if (!running_.exchange(false)) {
            return {error_info{1, "Health monitor is not running", "health_monitor"}};
        }
        return ok(std::monostate{});
    }

References kcenon::common::ok(), and running_.

Referenced by ~health_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unregister_check()

Result< bool > kcenon::common::interfaces::health_monitor::unregister_check ( const std::string & name )

inline

Unregister a health check.

Parameters

name	Name of the check to remove

Returns: Result indicating success or failure

Definition at line 127 of file health_monitor.h.

                                                         {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto result = graph_.remove_node(name);
        if (result.is_ok()) {
            --stats_.total_checks;
            recovery_handlers_.erase(name);
            last_results_.erase(name);
        }
        return result;
    }

References graph_, last_results_, mutex_, recovery_handlers_, kcenon::common::interfaces::health_dependency_graph::remove_node(), stats_, and kcenon::common::interfaces::health_monitor_stats::total_checks.

Here is the call graph for this function:

◆ update_stats_after_check()

void kcenon::common::interfaces::health_monitor::update_stats_after_check ( const health_check_result & result )

inlineprivate

Definition at line 333 of file health_monitor.h.

                                                                     {
        switch (result.status) {
            case health_status::healthy:
                ++stats_.healthy_count;
                break;
            case health_status::degraded:
                ++stats_.degraded_count;
                break;
            case health_status::unhealthy:
                ++stats_.unhealthy_count;
                break;
            case health_status::unknown:
                ++stats_.unknown_count;
                break;
        }
    }

References kcenon::common::interfaces::degraded, kcenon::common::interfaces::health_monitor_stats::degraded_count, kcenon::common::interfaces::healthy, kcenon::common::interfaces::health_monitor_stats::healthy_count, stats_, kcenon::common::interfaces::health_check_result::status, kcenon::common::interfaces::unhealthy, kcenon::common::interfaces::health_monitor_stats::unhealthy_count, kcenon::common::interfaces::unknown, and kcenon::common::interfaces::health_monitor_stats::unknown_count.

Referenced by check(), and refresh().

Here is the caller graph for this function:

Member Data Documentation

◆ graph_

health_dependency_graph kcenon::common::interfaces::health_monitor::graph_

private

Definition at line 382 of file health_monitor.h.

Referenced by add_dependency(), check(), get_check_names(), has_check(), refresh(), register_check(), and unregister_check().

◆ last_results_

std::unordered_map<std::string, health_check_result> kcenon::common::interfaces::health_monitor::last_results_

private

Definition at line 384 of file health_monitor.h.

Referenced by check(), get_health_report(), refresh(), and unregister_check().

◆ mutex_

std::mutex kcenon::common::interfaces::health_monitor::mutex_

mutableprivate

Definition at line 387 of file health_monitor.h.

Referenced by add_dependency(), check(), get_check_names(), get_health_report(), get_overall_status(), get_stats(), has_check(), refresh(), register_check(), register_recovery_handler(), and unregister_check().

◆ recovery_handlers_

std::unordered_map<std::string, recovery_handler> kcenon::common::interfaces::health_monitor::recovery_handlers_

private

Definition at line 383 of file health_monitor.h.

Referenced by attempt_recovery(), register_recovery_handler(), and unregister_check().

◆ running_

std::atomic<bool> kcenon::common::interfaces::health_monitor::running_ {false}

private

Definition at line 386 of file health_monitor.h.

386{false};

Referenced by is_running(), start(), and stop().

◆ stats_

health_monitor_stats kcenon::common::interfaces::health_monitor::stats_

private

Definition at line 385 of file health_monitor.h.

Referenced by attempt_recovery(), check(), get_health_report(), get_overall_status(), get_overall_status_internal(), get_stats(), refresh(), register_check(), unregister_check(), and update_stats_after_check().

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

include/kcenon/common/interfaces/monitoring/health_monitor.h

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ health_monitor() [1/3]

◆ ~health_monitor()

◆ health_monitor() [2/3]

◆ health_monitor() [3/3]

Member Function Documentation

◆ add_dependency()

◆ attempt_recovery()

◆ check()

◆ get_check_names()

◆ get_health_report()

◆ get_overall_status()

◆ get_overall_status_internal()

◆ get_overall_status_string()

◆ get_stats()

◆ has_check()

◆ is_running()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ refresh()

◆ register_check()

◆ register_recovery_handler()

◆ start()

◆ stop()

◆ unregister_check()

◆ update_stats_after_check()

Member Data Documentation

◆ graph_

◆ last_results_

◆ mutex_

◆ recovery_handlers_

◆ running_

◆ stats_