Directed acyclic graph for health check dependencies. More...

#include <health_monitor.h>

Collaboration diagram for kcenon::monitoring::health_dependency_graph:

Public Member Functions
common::Result< bool >	add_node (const std::string &name, std::shared_ptr< health_check > check)
	Add a health check node to the graph.

common::Result< bool >	add_dependency (const std::string &dependent, const std::string &dependency)
	Add a dependency edge: dependent depends on dependency.

std::vector< std::string >	get_dependencies (const std::string &name) const
	Get the direct dependencies of a node.

std::vector< std::string >	get_dependents (const std::string &name) const
	Get the nodes that directly depend on the given node.

bool	would_create_cycle (const std::string &from, const std::string &to) const
	Check whether adding an edge from -> to would create a cycle.

std::vector< std::string >	topological_sort () const
	Compute a topological ordering of all nodes.

health_check_result	check_with_dependencies (const std::string &name)
	Execute a health check after verifying all its dependencies are healthy.

std::vector< std::string >	get_failure_impact (const std::string &name) const
	Compute all nodes that would be impacted if the given node fails.

Private Member Functions
bool	would_create_cycle_internal (const std::string &from, const std::string &to) const

Private Attributes
std::shared_mutex	mutex_

std::unordered_map< std::string, std::shared_ptr< health_check > >	nodes_

std::unordered_map< std::string, std::vector< std::string > >	dependencies_

std::unordered_map< std::string, std::vector< std::string > >	dependents_

Detailed Description

Directed acyclic graph for health check dependencies.

Models dependency relationships between health checks so that a check's dependencies are verified before the check itself. Prevents circular dependencies and supports topological ordering and impact analysis.

Thread Safety

All public methods are thread-safe using std::shared_mutex (shared lock for reads, exclusive lock for writes).

See also: health_monitor For the primary consumer of this graph

Definition at line 337 of file health_monitor.h.

Member Function Documentation

◆ add_dependency()

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

inline

Add a dependency edge: dependent depends on dependency.

Parameters

dependent	Name of the node that depends on another
dependency	Name of the node being depended upon

Returns: Ok(true) on success, or error if nodes are not found or a cycle would be created

Definition at line 364 of file health_monitor.h.

                                                                                               {
        std::lock_guard<std::shared_mutex> lock(mutex_);
 
        if (nodes_.find(dependent) == nodes_.end()) {
            return common::Result<bool>::err(error_info(monitoring_error_code::not_found, "Dependent '" + dependent + "' not found").to_common_error());
        }
        if (nodes_.find(dependency) == nodes_.end()) {
            return common::Result<bool>::err(error_info(monitoring_error_code::not_found, "Dependency '" + dependency + "' not found").to_common_error());
        }
 
        if (would_create_cycle_internal(dependent, dependency)) {
            return common::Result<bool>::err(error_info(monitoring_error_code::invalid_state, "Adding dependency would create a cycle").to_common_error());
        }
 
        dependencies_[dependent].push_back(dependency);
        dependents_[dependency].push_back(dependent);
        return common::ok(true);
    }

References dependencies_, dependents_, kcenon::monitoring::invalid_state, mutex_, nodes_, kcenon::monitoring::not_found, and would_create_cycle_internal().

Referenced by kcenon::monitoring::health_monitor::add_dependency(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_node()

common::Result< bool > kcenon::monitoring::health_dependency_graph::add_node	(	const std::string &	name,
		std::shared_ptr< health_check >	check )

inline

Add a health check node to the graph.

Parameters

name	Unique name for this node
check	The health check implementation

Returns: Ok(true) on success, or error if the name already exists

Definition at line 345 of file health_monitor.h.

                                                                                          {
        std::lock_guard<std::shared_mutex> lock(mutex_);
 
        if (nodes_.find(name) != nodes_.end()) {
            return common::Result<bool>::err(error_info(monitoring_error_code::already_exists, "Node '" + name + "' already exists").to_common_error());
        }
 
        nodes_[name] = std::move(check);
        dependencies_[name] = {};
        dependents_[name] = {};
        return common::ok(true);
    }

References kcenon::monitoring::already_exists, dependencies_, dependents_, mutex_, and nodes_.

Referenced by kcenon::monitoring::health_monitor::register_check(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

◆ check_with_dependencies()

health_check_result kcenon::monitoring::health_dependency_graph::check_with_dependencies ( const std::string & name )

inline

Execute a health check after verifying all its dependencies are healthy.

Parameters

name	Node name to check

Returns: The check result; unhealthy/degraded if any dependency fails

Definition at line 473 of file health_monitor.h.

                                                                       {
        std::shared_lock<std::shared_mutex> lock(mutex_);
 
        auto it = nodes_.find(name);
        if (it == nodes_.end()) {
            return health_check_result::unhealthy("Node '" + name + "' not found");
        }
 
        auto deps_it = dependencies_.find(name);
        if (deps_it != dependencies_.end()) {
            for (const auto& dep_name : deps_it->second) {
                auto dep_it = nodes_.find(dep_name);
                if (dep_it != nodes_.end()) {
                    auto dep_result = dep_it->second->check();
                    if (dep_result.status == health_status::unhealthy) {
                        return health_check_result::unhealthy(
                            "Dependency '" + dep_name + "' is unhealthy: " + dep_result.message);
                    }
                    if (dep_result.status == health_status::degraded) {
                        return health_check_result::degraded(
                            "Dependency '" + dep_name + "' is degraded: " + dep_result.message);
                    }
                }
            }
        }
 
        return it->second->check();
    }

References kcenon::monitoring::health_check_result::degraded(), kcenon::monitoring::degraded, dependencies_, mutex_, nodes_, kcenon::monitoring::health_check_result::unhealthy(), and kcenon::monitoring::unhealthy.

Referenced by kcenon::monitoring::health_monitor::check(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_dependencies()

std::vector< std::string > kcenon::monitoring::health_dependency_graph::get_dependencies ( const std::string & name ) const

inline

Get the direct dependencies of a node.

Parameters

name	Node name to query

Returns: List of dependency names, or empty vector if node not found

Definition at line 388 of file health_monitor.h.

                                                                       {
        std::shared_lock<std::shared_mutex> lock(mutex_);
 
        auto it = dependencies_.find(name);
        if (it != dependencies_.end()) {
            return it->second;
        }
        return {};
    }

References dependencies_, and mutex_.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ get_dependents()

std::vector< std::string > kcenon::monitoring::health_dependency_graph::get_dependents ( const std::string & name ) const

inline

Get the nodes that directly depend on the given node.

Parameters

name	Node name to query

Returns: List of dependent names, or empty vector if node not found

Definition at line 403 of file health_monitor.h.

                                                                     {
        std::shared_lock<std::shared_mutex> lock(mutex_);
 
        auto it = dependents_.find(name);
        if (it != dependents_.end()) {
            return it->second;
        }
        return {};
    }

References dependents_, and mutex_.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ get_failure_impact()

std::vector< std::string > kcenon::monitoring::health_dependency_graph::get_failure_impact ( const std::string & name ) const

inline

Compute all nodes that would be impacted if the given node fails.

Parameters

name	Node name to analyze

Returns: List of all transitively dependent node names

Definition at line 507 of file health_monitor.h.

                                                                         {
        std::shared_lock<std::shared_mutex> lock(mutex_);
 
        std::vector<std::string> impacted;
        std::unordered_set<std::string> visited;
        std::queue<std::string> to_visit;
 
        auto it = dependents_.find(name);
        if (it != dependents_.end()) {
            for (const auto& dep : it->second) {
                to_visit.push(dep);
            }
        }
 
        while (!to_visit.empty()) {
            std::string current = to_visit.front();
            to_visit.pop();
 
            if (visited.find(current) != visited.end()) {
                continue;
            }
            visited.insert(current);
            impacted.push_back(current);
 
            auto dep_it = dependents_.find(current);
            if (dep_it != dependents_.end()) {
                for (const auto& dep : dep_it->second) {
                    if (visited.find(dep) == visited.end()) {
                        to_visit.push(dep);
                    }
                }
            }
        }
 
        return impacted;
    }

References dependents_, and mutex_.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ topological_sort()

std::vector< std::string > kcenon::monitoring::health_dependency_graph::topological_sort ( ) const

inline

Compute a topological ordering of all nodes.

Returns: Node names in dependency order (dependencies before dependents)

Definition at line 428 of file health_monitor.h.

                                                  {
        std::shared_lock<std::shared_mutex> lock(mutex_);
 
        std::unordered_map<std::string, int> in_degree;
        for (const auto& [name, _] : nodes_) {
            in_degree[name] = 0;
        }
 
        for (const auto& [name, deps] : dependencies_) {
            in_degree[name] = static_cast<int>(deps.size());
        }
 
        std::queue<std::string> queue;
        for (const auto& [name, degree] : in_degree) {
            if (degree == 0) {
                queue.push(name);
            }
        }
 
        std::vector<std::string> result;
        result.reserve(nodes_.size());
 
        while (!queue.empty()) {
            std::string current = queue.front();
            queue.pop();
            result.push_back(current);
 
            auto it = dependents_.find(current);
            if (it != dependents_.end()) {
                for (const auto& dep : it->second) {
                    if (--in_degree[dep] == 0) {
                        queue.push(dep);
                    }
                }
            }
        }
 
        return result;
    }

References dependencies_, dependents_, mutex_, and nodes_.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ would_create_cycle()

bool kcenon::monitoring::health_dependency_graph::would_create_cycle	(	const std::string &	from,
		const std::string &	to ) const

inline

Check whether adding an edge from -> to would create a cycle.

Parameters

from	Source node name
to	Target node name

Returns: true if the edge would create a cycle

Definition at line 419 of file health_monitor.h.

                                                                              {
        std::shared_lock<std::shared_mutex> lock(mutex_);
        return would_create_cycle_internal(from, to);
    }

References mutex_, and would_create_cycle_internal().

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ would_create_cycle_internal()

bool kcenon::monitoring::health_dependency_graph::would_create_cycle_internal	(	const std::string &	from,
		const std::string &	to ) const

inlineprivate

Definition at line 545 of file health_monitor.h.

                                                                                       {
        if (from == to) {
            return true;
        }
 
        std::unordered_set<std::string> visited;
        std::queue<std::string> to_visit;
        to_visit.push(to);
 
        while (!to_visit.empty()) {
            std::string current = to_visit.front();
            to_visit.pop();
 
            if (current == from) {
                return true;
            }
 
            if (visited.find(current) != visited.end()) {
                continue;
            }
            visited.insert(current);
 
            auto it = dependencies_.find(current);
            if (it != dependencies_.end()) {
                for (const auto& dep : it->second) {
                    if (visited.find(dep) == visited.end()) {
                        to_visit.push(dep);
                    }
                }
            }
        }
 
        return false;
    }

References dependencies_.

Referenced by add_dependency(), and would_create_cycle().

Here is the caller graph for this function:

Member Data Documentation

◆ dependencies_

std::unordered_map<std::string, std::vector<std::string> > kcenon::monitoring::health_dependency_graph::dependencies_

private

Definition at line 582 of file health_monitor.h.

Referenced by add_dependency(), add_node(), check_with_dependencies(), get_dependencies(), topological_sort(), and would_create_cycle_internal().

◆ dependents_

std::unordered_map<std::string, std::vector<std::string> > kcenon::monitoring::health_dependency_graph::dependents_

private

Definition at line 583 of file health_monitor.h.

Referenced by add_dependency(), add_node(), get_dependents(), get_failure_impact(), and topological_sort().

◆ mutex_

std::shared_mutex kcenon::monitoring::health_dependency_graph::mutex_

mutableprivate

Definition at line 580 of file health_monitor.h.

Referenced by add_dependency(), add_node(), check_with_dependencies(), get_dependencies(), get_dependents(), get_failure_impact(), topological_sort(), and would_create_cycle().

◆ nodes_

std::unordered_map<std::string, std::shared_ptr<health_check> > kcenon::monitoring::health_dependency_graph::nodes_

private

Definition at line 581 of file health_monitor.h.

Referenced by add_dependency(), add_node(), check_with_dependencies(), and topological_sort().

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

include/kcenon/monitoring/health/health_monitor.h

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Thread Safety

Member Function Documentation

◆ add_dependency()

◆ add_node()

◆ check_with_dependencies()

◆ get_dependencies()

◆ get_dependents()

◆ get_failure_impact()

◆ topological_sort()

◆ would_create_cycle()

◆ would_create_cycle_internal()

Member Data Documentation

◆ dependencies_

◆ dependents_

◆ mutex_

◆ nodes_