Dynamic registry for alert rules with hot-reload support. More...

#include <alert_config.h>

Collaboration diagram for kcenon::monitoring::rule_registry:

Public Types
using	rule_change_callback

Public Member Functions
common::VoidResult	register_rule (std::shared_ptr< alert_rule > rule)
	Register a rule.

common::VoidResult	unregister_rule (const std::string &name)
	Unregister a rule.

std::shared_ptr< alert_rule >	get_rule (const std::string &name) const
	Get a rule by name.

std::vector< std::shared_ptr< alert_rule > >	get_all_rules () const
	Get all registered rules.

std::vector< std::shared_ptr< alert_rule > >	get_rules_by_group (const std::string &group) const
	Get rules in a group.

size_t	rule_count () const
	Get rule count.

void	on_rule_change (rule_change_callback callback)
	Register callback for rule changes.

common::Result< size_t >	load_definitions (const std::vector< rule_definition > &definitions)
	Load rules from definitions.

void	clear ()
	Clear all rules.

Private Attributes
std::mutex	mutex_

std::unordered_map< std::string, std::shared_ptr< alert_rule > >	rules_

std::vector< rule_change_callback >	change_callbacks_

Detailed Description

Dynamic registry for alert rules with hot-reload support.

Manages a collection of alert rules and supports runtime updates without service interruption.

Definition at line 387 of file alert_config.h.

Member Typedef Documentation

◆ rule_change_callback

using kcenon::monitoring::rule_registry::rule_change_callback

Initial value:

 std::function<void(
        const std::string& rule_name,
        const std::shared_ptr<alert_rule>& rule,
        bool is_removal)>

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 389 of file alert_config.h.

Member Function Documentation

◆ clear()

void kcenon::monitoring::rule_registry::clear ( )

inline

Clear all rules.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 530 of file alert_config.h.

                 {
        std::lock_guard<std::mutex> lock(mutex_);
 
        for (const auto& [name, rule] : rules_) {
            for (const auto& callback : change_callbacks_) {
                callback(name, rule, true);
            }
        }
 
        rules_.clear();
    }

References change_callbacks_, mutex_, and rules_.

◆ get_all_rules()

std::vector< std::shared_ptr< alert_rule > > kcenon::monitoring::rule_registry::get_all_rules ( ) const

inline

Get all registered rules.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 454 of file alert_config.h.

                                                               {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<std::shared_ptr<alert_rule>> result;
        result.reserve(rules_.size());
        for (const auto& [name, rule] : rules_) {
            result.push_back(rule);
        }
        return result;
    }

References mutex_, and rules_.

◆ get_rule()

std::shared_ptr< alert_rule > kcenon::monitoring::rule_registry::get_rule ( const std::string & name ) const

inline

Get a rule by name.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 445 of file alert_config.h.

                                                                    {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = rules_.find(name);
        return it != rules_.end() ? it->second : nullptr;
    }

References mutex_, and rules_.

◆ get_rules_by_group()

std::vector< std::shared_ptr< alert_rule > > kcenon::monitoring::rule_registry::get_rules_by_group ( const std::string & group ) const

inline

Get rules in a group.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 467 of file alert_config.h.

                                          {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<std::shared_ptr<alert_rule>> result;
        for (const auto& [name, rule] : rules_) {
            if (rule->group() == group) {
                result.push_back(rule);
            }
        }
        return result;
    }

References mutex_, and rules_.

◆ load_definitions()

common::Result< size_t > kcenon::monitoring::rule_registry::load_definitions ( const std::vector< rule_definition > & definitions )

inline

Load rules from definitions.

Parameters

definitions Vector of rule definitions

Returns: Result with count of successfully loaded rules

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 500 of file alert_config.h.

                                                                                         {
        size_t loaded = 0;
        std::vector<std::string> errors;
 
        for (const auto& def : definitions) {
            auto rule_result = rule_builder::build(def);
            if (rule_result.is_ok()) {
                auto reg_result = register_rule(rule_result.value());
                if (reg_result.is_ok()) {
                    ++loaded;
                } else {
                    errors.push_back(def.name + ": " + reg_result.error().message);
                }
            } else {
                errors.push_back(def.name + ": " + rule_result.error().message);
            }
        }
 
        if (!errors.empty() && loaded == 0) {
            return common::make_error<size_t>(
                static_cast<int>(monitoring_error_code::configuration_parse_error),
                "Failed to load any rules: " + errors.front());
        }
 
        return common::ok(loaded);
    }

References kcenon::monitoring::rule_builder::build(), kcenon::monitoring::configuration_parse_error, and register_rule().

Here is the call graph for this function:

◆ on_rule_change()

void kcenon::monitoring::rule_registry::on_rule_change ( rule_change_callback callback )

inline

Register callback for rule changes.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 490 of file alert_config.h.

                                                       {
        std::lock_guard<std::mutex> lock(mutex_);
        change_callbacks_.push_back(std::move(callback));
    }

References change_callbacks_, and mutex_.

◆ register_rule()

common::VoidResult kcenon::monitoring::rule_registry::register_rule ( std::shared_ptr< alert_rule > rule )

inline

Register a rule.

Parameters

rule	Rule to register

Returns: Result indicating success or failure

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 399 of file alert_config.h.

                                                                   {
        if (!rule) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_argument, "Rule cannot be null").to_common_error());
        }
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        std::string name = rule->name();
        rules_[name] = rule;
 
        // Notify listeners
        for (const auto& callback : change_callbacks_) {
            callback(name, rule, false);
        }
 
        return common::ok();
    }

References change_callbacks_, kcenon::monitoring::invalid_argument, mutex_, and rules_.

Referenced by load_definitions().

Here is the caller graph for this function:

◆ rule_count()

size_t kcenon::monitoring::rule_registry::rule_count ( ) const

inline

Get rule count.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 482 of file alert_config.h.

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

References mutex_, and rules_.

◆ unregister_rule()

common::VoidResult kcenon::monitoring::rule_registry::unregister_rule ( const std::string & name )

inline

Unregister a rule.

Parameters

name Rule name

Returns: Result indicating success or failure

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_config.h.

Definition at line 422 of file alert_config.h.

                                                            {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto it = rules_.find(name);
        if (it == rules_.end()) {
            return common::VoidResult::err(static_cast<int>(monitoring_error_code::not_found),
                                   "Rule not found: " + name);
        }
 
        auto rule = it->second;
        rules_.erase(it);
 
        // Notify listeners
        for (const auto& callback : change_callbacks_) {
            callback(name, rule, true);
        }
 
        return common::ok();
    }