alert_rule.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "alert_types.h"
#include "../core/result_types.h"
 
namespace kcenon::monitoring {
 
// Forward declarations
class alert_trigger;
 
struct alert_rule_config {
    std::chrono::milliseconds evaluation_interval{15000};       
    std::chrono::milliseconds for_duration{0};                  
    std::chrono::milliseconds repeat_interval{300000};          
    bool keep_firing_for{false};                                
    std::chrono::milliseconds keep_firing_duration{300000};     
 
    bool validate() const {
        if (evaluation_interval.count() <= 0) {
            return false;
        }
        if (repeat_interval.count() <= 0) {
            return false;
        }
        return true;
    }
};
 
class alert_rule {
public:
    explicit alert_rule(std::string name)
        : name_(std::move(name))
        , enabled_(true) {}
 
    const std::string& name() const { return name_; }
 
    const std::string& group() const { return group_; }
 
    alert_rule& set_group(std::string group_name) {
        group_ = std::move(group_name);
        return *this;
    }
 
    alert_severity severity() const { return severity_; }
 
    alert_rule& set_severity(alert_severity sev) {
        severity_ = sev;
        return *this;
    }
 
    const alert_labels& labels() const { return labels_; }
 
    alert_rule& add_label(const std::string& key, const std::string& value) {
        labels_.set(key, value);
        return *this;
    }
 
    const alert_annotations& annotations() const { return annotations_; }
 
    alert_rule& set_summary(std::string summary) {
        annotations_.summary = std::move(summary);
        return *this;
    }
 
    alert_rule& set_description(std::string description) {
        annotations_.description = std::move(description);
        return *this;
    }
 
    alert_rule& set_runbook_url(std::string url) {
        annotations_.runbook_url = std::move(url);
        return *this;
    }
 
    const alert_rule_config& config() const { return config_; }
 
    alert_rule& set_evaluation_interval(std::chrono::milliseconds interval) {
        config_.evaluation_interval = interval;
        return *this;
    }
 
    alert_rule& set_for_duration(std::chrono::milliseconds duration) {
        config_.for_duration = duration;
        return *this;
    }
 
    alert_rule& set_repeat_interval(std::chrono::milliseconds interval) {
        config_.repeat_interval = interval;
        return *this;
    }
 
    bool is_enabled() const { return enabled_; }
 
    alert_rule& set_enabled(bool enabled) {
        enabled_ = enabled;
        return *this;
    }
 
    alert_rule& set_trigger(std::shared_ptr<alert_trigger> trigger) {
        trigger_ = std::move(trigger);
        return *this;
    }
 
    std::shared_ptr<alert_trigger> trigger() const { return trigger_; }
 
    alert create_alert(double value) const {
        alert a(name_, labels_);
        a.annotations = annotations_;
        a.severity = severity_;
        a.value = value;
        a.rule_name = name_;
        a.group_key = group_.empty() ? name_ : group_;
        return a;
    }
 
    common::VoidResult validate() const {
        if (name_.empty()) {
            error_info err(monitoring_error_code::invalid_argument,
                          "Rule name cannot be empty");
            return common::VoidResult::err(err.to_common_error());
        }
        if (!config_.validate()) {
            error_info err(monitoring_error_code::invalid_configuration,
                          "Rule configuration is invalid");
            return common::VoidResult::err(err.to_common_error());
        }
        if (!trigger_) {
            error_info err(monitoring_error_code::invalid_argument,
                          "Rule must have a trigger");
            return common::VoidResult::err(err.to_common_error());
        }
        return common::ok();
    }
 
    const std::string& metric_name() const { return metric_name_; }
 
    alert_rule& set_metric_name(std::string name) {
        metric_name_ = std::move(name);
        return *this;
    }
 
private:
    std::string name_;
    std::string group_;
    std::string metric_name_;
    alert_severity severity_ = alert_severity::warning;
    alert_labels labels_;
    alert_annotations annotations_;
    alert_rule_config config_;
    bool enabled_;
    std::shared_ptr<alert_trigger> trigger_;
};
 
class alert_trigger {
public:
    virtual ~alert_trigger() = default;
 
    virtual bool evaluate(double value) const = 0;
 
    virtual std::string type_name() const = 0;
 
    virtual std::string description() const = 0;
};
 
class alert_rule_group {
public:
    explicit alert_rule_group(std::string name)
        : name_(std::move(name)) {}
 
    const std::string& name() const { return name_; }
 
    void add_rule(std::shared_ptr<alert_rule> rule) {
        if (rule) {
            rule->set_group(name_);
            rules_.push_back(std::move(rule));
        }
    }
 
    const std::vector<std::shared_ptr<alert_rule>>& rules() const {
        return rules_;
    }
 
    size_t size() const { return rules_.size(); }
 
    bool empty() const { return rules_.empty(); }
 
    void set_common_interval(std::chrono::milliseconds interval) {
        common_interval_ = interval;
        for (auto& rule : rules_) {
            rule->set_evaluation_interval(interval);
        }
    }
 
    std::optional<std::chrono::milliseconds> common_interval() const {
        return common_interval_;
    }
 
private:
    std::string name_;
    std::vector<std::shared_ptr<alert_rule>> rules_;
    std::optional<std::chrono::milliseconds> common_interval_;
};
 
} // namespace kcenon::monitoring