Aggregates multiple health checks into a single check. More...

#include <composite_health_check.h>

Inheritance diagram for kcenon::common::interfaces::composite_health_check:

Collaboration diagram for kcenon::common::interfaces::composite_health_check:

Public Member Functions
	composite_health_check (std::string name, health_check_type type=health_check_type::custom, bool critical=true)
	Construct a composite health check.

std::string	get_name () const override
	Get the unique name of this health check.

health_check_type	get_type () const override
	Get the type of this health check.

bool	is_critical () const override
	Check if this health check is critical.

health_check_result	check () override
	Execute all child health checks and aggregate results.

void	add_check (std::shared_ptr< health_check > check)
	Add a child health check.

bool	remove_check (const std::string &name)
	Remove a child health check by name.

std::size_t	size () const
	Get the number of child checks.

bool	empty () const
	Check if this composite has no child checks.

void	clear ()
	Clear all child checks.

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

Public Member Functions inherited from kcenon::common::interfaces::health_check
	health_check ()=default

virtual	~health_check ()=default

	health_check (const health_check &)=delete

health_check &	operator= (const health_check &)=delete

	health_check (health_check &&)=delete

health_check &	operator= (health_check &&)=delete

virtual std::chrono::milliseconds	get_timeout () const
	Get timeout duration for this health check.

Private Attributes
std::string	name_

health_check_type	type_

bool	critical_

std::vector< std::shared_ptr< health_check > >	checks_

std::mutex	mutex_

Detailed Description

Aggregates multiple health checks into a single check.

This class implements the Composite pattern for health checks, allowing multiple checks to be grouped and executed together. The overall health status is determined by the worst status among all child checks.

Example usage:

auto composite = std::make_shared<composite_health_check>("system_health");
composite->add_check(database_check);
composite->add_check(cache_check);
composite->add_check(queue_check);
 
auto result = composite->check();  // Runs all checks

Definition at line 43 of file composite_health_check.h.

Constructor & Destructor Documentation

◆ composite_health_check()

kcenon::common::interfaces::composite_health_check::composite_health_check	(	std::string	name,
		health_check_type	type = health_check_type::custom,
		bool	critical = true )

inlineexplicit

Construct a composite health check.

Parameters

name	Name for this composite check
type	Health check type (default: custom)
critical	Whether this composite is critical (default: true)

Definition at line 51 of file composite_health_check.h.

55 : name_(std::move(name)), type_(type), critical_(critical) {}

kcenon::common::interfaces::composite_health_check::critical_

bool critical_

Definition composite_health_check.h:208

kcenon::common::interfaces::composite_health_check::name_

std::string name_

Definition composite_health_check.h:206

kcenon::common::interfaces::composite_health_check::type_

health_check_type type_

Definition composite_health_check.h:207

kcenon::common::interfaces::log_level::critical

@ critical

Member Function Documentation

◆ add_check()

void kcenon::common::interfaces::composite_health_check::add_check ( std::shared_ptr< health_check > check )

inline

Add a child health check.

Parameters

check Health check to add

Definition at line 139 of file composite_health_check.h.

                                                      {
        if (!check) {
            return;
        }
        std::lock_guard<std::mutex> lock(mutex_);
        checks_.push_back(std::move(check));
    }

References check(), checks_, and mutex_.

Here is the call graph for this function:

◆ check()

health_check_result kcenon::common::interfaces::composite_health_check::check ( )

inlineoverridevirtual

Execute all child health checks and aggregate results.

Returns: Aggregated health check result

The overall status is determined as follows:

UNHEALTHY if any child is UNHEALTHY
DEGRADED if any child is DEGRADED (and none are UNHEALTHY)
UNKNOWN if any child is UNKNOWN (and none are worse)
HEALTHY only if all children are HEALTHY

Implements kcenon::common::interfaces::health_check.

Definition at line 73 of file composite_health_check.h.

                                         {
        std::lock_guard<std::mutex> lock(mutex_);
 
        health_check_result result;
        result.status = health_status::healthy;
        auto start_time = std::chrono::steady_clock::now();
 
        std::vector<std::string> messages;
        std::size_t healthy_count = 0;
        std::size_t degraded_count = 0;
        std::size_t unhealthy_count = 0;
 
        for (const auto& check : checks_) {
            auto child_result = check->check();
 
            switch (child_result.status) {
                case health_status::unhealthy:
                    ++unhealthy_count;
                    result.status = health_status::unhealthy;
                    messages.push_back(check->get_name() + ": " + child_result.message);
                    break;
                case health_status::degraded:
                    ++degraded_count;
                    if (result.status != health_status::unhealthy) {
                        result.status = health_status::degraded;
                    }
                    messages.push_back(check->get_name() + ": " + child_result.message);
                    break;
                case health_status::unknown:
                    if (result.status == health_status::healthy) {
                        result.status = health_status::unknown;
                    }
                    messages.push_back(check->get_name() + ": " + child_result.message);
                    break;
                case health_status::healthy:
                    ++healthy_count;
                    break;
            }
        }
 
        auto end_time = std::chrono::steady_clock::now();
        result.check_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
            end_time - start_time);
 
        if (messages.empty()) {
            result.message = "All " + std::to_string(healthy_count) + " checks passed";
        } else {
            result.message = std::to_string(unhealthy_count) + " unhealthy, " +
                             std::to_string(degraded_count) + " degraded";
            for (const auto& msg : messages) {
                result.message += "; " + msg;
            }
        }
 
        result.metadata["total_checks"] = std::to_string(checks_.size());
        result.metadata["healthy_count"] = std::to_string(healthy_count);
        result.metadata["degraded_count"] = std::to_string(degraded_count);
        result.metadata["unhealthy_count"] = std::to_string(unhealthy_count);
 
        return result;
    }

References check(), kcenon::common::interfaces::health_check_result::check_duration, checks_, kcenon::common::interfaces::degraded, kcenon::common::interfaces::healthy, kcenon::common::interfaces::health_check_result::message, kcenon::common::interfaces::health_check_result::metadata, mutex_, kcenon::common::interfaces::health_check_result::status, kcenon::common::interfaces::unhealthy, and kcenon::common::interfaces::unknown.

Referenced by add_check(), check(), get_check_names(), and remove_check().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

void kcenon::common::interfaces::composite_health_check::clear ( )

inline

Clear all child checks.

Definition at line 186 of file composite_health_check.h.

                 {
        std::lock_guard<std::mutex> lock(mutex_);
        checks_.clear();
    }

References checks_, and mutex_.

◆ empty()

bool kcenon::common::interfaces::composite_health_check::empty ( ) const

inlinenodiscard

Check if this composite has no child checks.

Returns: true if empty

Definition at line 178 of file composite_health_check.h.

                                     {
        std::lock_guard<std::mutex> lock(mutex_);
        return checks_.empty();
    }

References checks_, and mutex_.

◆ get_check_names()

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

inlinenodiscard

Get all child check names.

Returns: Vector of check names

Definition at line 195 of file composite_health_check.h.

                                                               {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<std::string> names;
        names.reserve(checks_.size());
        for (const auto& check : checks_) {
            names.push_back(check->get_name());
        }
        return names;
    }

References check(), checks_, and mutex_.

Here is the call graph for this function:

◆ get_name()

std::string kcenon::common::interfaces::composite_health_check::get_name ( ) const

inlinenodiscardoverridevirtual

Get the unique name of this health check.

Returns: Health check name

Implements kcenon::common::interfaces::health_check.

Definition at line 57 of file composite_health_check.h.

57{ return name_; }

References name_.

◆ get_type()

health_check_type kcenon::common::interfaces::composite_health_check::get_type ( ) const

inlinenodiscardoverridevirtual

Get the type of this health check.

Returns: Health check type

Implements kcenon::common::interfaces::health_check.

Definition at line 59 of file composite_health_check.h.

59{ return type_; }

References type_.

◆ is_critical()

bool kcenon::common::interfaces::composite_health_check::is_critical ( ) const

inlinenodiscardoverridevirtual

Check if this health check is critical.

Critical health checks affect the overall system health status. Non-critical checks are reported but don't impact system health.

Returns: true if this is a critical health check

Implements kcenon::common::interfaces::health_check.

Definition at line 61 of file composite_health_check.h.

61{ return critical_; }

References critical_.

◆ remove_check()

bool kcenon::common::interfaces::composite_health_check::remove_check ( const std::string & name )

inline

Remove a child health check by name.

Parameters

name	Name of the check to remove

Returns: true if check was found and removed

Definition at line 152 of file composite_health_check.h.

                                             {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = std::find_if(checks_.begin(), checks_.end(),
                               [&name](const std::shared_ptr<health_check>& check) {
                                   return check->get_name() == name;
                               });
        if (it != checks_.end()) {
            checks_.erase(it);
            return true;
        }
        return false;
    }

References check(), checks_, and mutex_.

Here is the call graph for this function:

◆ size()

std::size_t kcenon::common::interfaces::composite_health_check::size ( ) const

inlinenodiscard

Get the number of child checks.

Returns: Number of child checks

Definition at line 169 of file composite_health_check.h.

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

References checks_, and mutex_.

Member Data Documentation

◆ checks_

std::vector<std::shared_ptr<health_check> > kcenon::common::interfaces::composite_health_check::checks_

private

Definition at line 209 of file composite_health_check.h.

Referenced by add_check(), check(), clear(), empty(), get_check_names(), remove_check(), and size().

◆ critical_

bool kcenon::common::interfaces::composite_health_check::critical_

private

Definition at line 208 of file composite_health_check.h.

Referenced by is_critical().

◆ mutex_

std::mutex kcenon::common::interfaces::composite_health_check::mutex_

mutableprivate

Definition at line 210 of file composite_health_check.h.

Referenced by add_check(), check(), clear(), empty(), get_check_names(), remove_check(), and size().

◆ name_

std::string kcenon::common::interfaces::composite_health_check::name_

private

Definition at line 206 of file composite_health_check.h.

Referenced by get_name().

◆ type_

health_check_type kcenon::common::interfaces::composite_health_check::type_

private

Definition at line 207 of file composite_health_check.h.

Referenced by get_type().

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

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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ composite_health_check()

Member Function Documentation

◆ add_check()

◆ check()

◆ clear()

◆ empty()

◆ get_check_names()

◆ get_name()

◆ get_type()

◆ is_critical()

◆ remove_check()

◆ size()

Member Data Documentation

◆ checks_

◆ critical_

◆ mutex_

◆ name_

◆ type_