Builds alert_rule from rule_definition. More...

#include <alert_config.h>

Collaboration diagram for kcenon::monitoring::rule_builder:

Static Public Member Functions
static common::Result< std::shared_ptr< alert_rule > >	build (const rule_definition &def)
	Build alert_rule from definition.

Static Private Member Functions
static common::Result< alert_severity >	parse_severity (const std::string &str)

static common::Result< std::shared_ptr< alert_trigger > >	build_trigger (const rule_definition::trigger_config &cfg)

static common::Result< comparison_operator >	parse_operator (const std::string &str)

Detailed Description

Builds alert_rule from rule_definition.

Provides validation and construction of alert rules from configuration definitions.

Definition at line 220 of file alert_config.h.

Member Function Documentation

◆ build()

static common::Result< std::shared_ptr< alert_rule > > kcenon::monitoring::rule_builder::build ( const rule_definition & def )

inlinestatic

Build alert_rule from definition.

Parameters

def	Rule definition

Returns: Result containing built rule or error

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

Definition at line 227 of file alert_config.h.

                                                                                     {
        // Validate required fields
        if (def.name.empty()) {
            return common::make_error<std::shared_ptr<alert_rule>>(
                static_cast<int>(monitoring_error_code::invalid_argument),
                "Rule name is required");
        }
        if (def.metric_name.empty()) {
            return common::make_error<std::shared_ptr<alert_rule>>(
                static_cast<int>(monitoring_error_code::invalid_argument),
                "Metric name is required");
        }
 
        auto rule = std::make_shared<alert_rule>(def.name);
 
        // Set group
        if (!def.group.empty()) {
            rule->set_group(def.group);
        }
 
        // Set metric name
        rule->set_metric_name(def.metric_name);
 
        // Set severity
        auto severity = parse_severity(def.severity);
        if (!severity.is_ok()) {
            return common::make_error<std::shared_ptr<alert_rule>>(
                static_cast<int>(monitoring_error_code::invalid_argument),
                severity.error().message);
        }
        rule->set_severity(severity.value());
 
        // Set enabled
        rule->set_enabled(def.enabled);
 
        // Build trigger
        auto trigger = build_trigger(def.trigger);
        if (!trigger.is_ok()) {
            return common::make_error<std::shared_ptr<alert_rule>>(
                static_cast<int>(monitoring_error_code::invalid_argument),
                trigger.error().message);
        }
        rule->set_trigger(trigger.value());
 
        // Set timing
        rule->set_evaluation_interval(
            std::chrono::seconds(def.evaluation_interval_seconds));
        rule->set_for_duration(
            std::chrono::seconds(def.for_duration_seconds));
        rule->set_repeat_interval(
            std::chrono::seconds(def.repeat_interval_seconds));
 
        // Set labels
        for (const auto& [key, value] : def.labels) {
            rule->add_label(key, value);
        }
 
        // Set annotations
        if (!def.summary.empty()) {
            rule->set_summary(def.summary);
        }
        if (!def.description.empty()) {
            rule->set_description(def.description);
        }
        if (!def.runbook_url.empty()) {
            rule->set_runbook_url(def.runbook_url);
        }
 
        return common::ok(std::move(rule));
    }

Referenced by kcenon::monitoring::rule_registry::load_definitions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_trigger()

static common::Result< std::shared_ptr< alert_trigger > > kcenon::monitoring::rule_builder::build_trigger ( const rule_definition::trigger_config & cfg )

inlinestaticprivate

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

Definition at line 317 of file alert_config.h.

                                                      {
        if (cfg.type.empty() || cfg.type == "threshold") {
            auto op = parse_operator(cfg.operator_str);
            if (!op.is_ok()) {
                return common::make_error<std::shared_ptr<alert_trigger>>(
                    static_cast<int>(monitoring_error_code::invalid_argument),
                    op.error().message);
            }
            return common::ok(std::shared_ptr<alert_trigger>(
                std::make_shared<threshold_trigger>(cfg.threshold, op.value())));
        }
 
        if (cfg.type == "rate") {
            return common::ok(std::shared_ptr<alert_trigger>(
                std::make_shared<rate_of_change_trigger>(
                    cfg.rate_threshold,
                    std::chrono::seconds(cfg.window_seconds))));
        }
 
        if (cfg.type == "anomaly") {
            return common::ok(std::shared_ptr<alert_trigger>(
                std::make_shared<anomaly_trigger>(
                    cfg.sensitivity,
                    static_cast<size_t>(cfg.window_seconds))));
        }
 
        if (cfg.type == "absent") {
            return common::ok(std::shared_ptr<alert_trigger>(
                std::make_shared<absent_trigger>(
                    std::chrono::seconds(cfg.absent_seconds))));
        }
 
        return common::make_error<std::shared_ptr<alert_trigger>>(
            static_cast<int>(monitoring_error_code::invalid_argument),
            "Unknown trigger type: " + cfg.type);
    }

References kcenon::monitoring::rule_definition::trigger_config::absent_seconds, kcenon::monitoring::invalid_argument, kcenon::monitoring::rule_definition::trigger_config::operator_str, parse_operator(), kcenon::monitoring::rule_definition::trigger_config::rate_threshold, kcenon::monitoring::rule_definition::trigger_config::sensitivity, kcenon::monitoring::rule_definition::trigger_config::threshold, kcenon::monitoring::rule_definition::trigger_config::type, and kcenon::monitoring::rule_definition::trigger_config::window_seconds.

Referenced by build().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_operator()

static common::Result< comparison_operator > kcenon::monitoring::rule_builder::parse_operator ( const std::string & str )

inlinestaticprivate

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

Definition at line 355 of file alert_config.h.

                                                                                  {
        if (str.empty() || str == ">") {
            return common::ok(comparison_operator::greater_than);
        }
        if (str == ">=") {
            return common::ok(comparison_operator::greater_or_equal);
        }
        if (str == "<") {
            return common::ok(comparison_operator::less_than);
        }
        if (str == "<=") {
            return common::ok(comparison_operator::less_or_equal);
        }
        if (str == "==" || str == "=") {
            return common::ok(comparison_operator::equal);
        }
        if (str == "!=" || str == "<>") {
            return common::ok(comparison_operator::not_equal);
        }
        return common::make_error<comparison_operator>(
            static_cast<int>(monitoring_error_code::invalid_argument),
            "Unknown operator: " + str);
    }

References kcenon::monitoring::equal, kcenon::monitoring::greater_or_equal, kcenon::monitoring::greater_than, kcenon::monitoring::invalid_argument, kcenon::monitoring::less_or_equal, kcenon::monitoring::less_than, and kcenon::monitoring::not_equal.

Referenced by build_trigger().

Here is the caller graph for this function:

◆ parse_severity()

static common::Result< alert_severity > kcenon::monitoring::rule_builder::parse_severity ( const std::string & str )

inlinestaticprivate

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

Definition at line 299 of file alert_config.h.

                                                                             {
        if (str.empty() || str == "warning") {
            return common::ok(alert_severity::warning);
        }
        if (str == "info") {
            return common::ok(alert_severity::info);
        }
        if (str == "critical") {
            return common::ok(alert_severity::critical);
        }
        if (str == "emergency") {
            return common::ok(alert_severity::emergency);
        }
        return common::make_error<alert_severity>(
            static_cast<int>(monitoring_error_code::invalid_argument),
            "Unknown severity: " + str);
    }

References kcenon::monitoring::critical, kcenon::monitoring::emergency, kcenon::monitoring::info, kcenon::monitoring::invalid_argument, and kcenon::monitoring::warning.

Referenced by build().

Here is the caller graph for this function:

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

include/kcenon/monitoring/alert/alert_config.h

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation

◆ build()

◆ build_trigger()

◆ parse_operator()

◆ parse_severity()