alert_manager.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 <atomic>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>
 
#include "alert_rule.h"
#include "alert_types.h"
#include "../core/result_types.h"
#include "../interfaces/event_bus_interface.h"
 
namespace kcenon::monitoring {
 
// Forward declarations
class alert_notifier;
 
struct alert_manager_config {
    std::chrono::milliseconds default_evaluation_interval{15000};   
    std::chrono::milliseconds default_repeat_interval{300000};      
    size_t max_alerts_per_rule{100};                                
    size_t max_silences{1000};                                      
    bool enable_grouping{true};                                     
    std::chrono::milliseconds group_wait{30000};                    
    std::chrono::milliseconds group_interval{300000};               
    std::chrono::milliseconds resolve_timeout{300000};              
 
    bool validate() const {
        return default_evaluation_interval.count() > 0 &&
               default_repeat_interval.count() > 0 &&
               max_alerts_per_rule > 0 &&
               max_silences > 0;
    }
};
 
struct alert_manager_metrics {
    std::atomic<uint64_t> rules_evaluated{0};
    std::atomic<uint64_t> alerts_created{0};
    std::atomic<uint64_t> alerts_resolved{0};
    std::atomic<uint64_t> alerts_suppressed{0};
    std::atomic<uint64_t> notifications_sent{0};
    std::atomic<uint64_t> notifications_failed{0};
 
    alert_manager_metrics() = default;
 
    alert_manager_metrics(const alert_manager_metrics& other)
        : rules_evaluated(other.rules_evaluated.load())
        , alerts_created(other.alerts_created.load())
        , alerts_resolved(other.alerts_resolved.load())
        , alerts_suppressed(other.alerts_suppressed.load())
        , notifications_sent(other.notifications_sent.load())
        , notifications_failed(other.notifications_failed.load()) {}
};
 
class alert_manager {
public:
    using metric_provider_func = std::function<std::optional<double>(const std::string&)>;
 
    alert_manager();
 
    explicit alert_manager(const alert_manager_config& config);
 
    ~alert_manager();
 
    // Non-copyable, non-movable
    alert_manager(const alert_manager&) = delete;
    alert_manager& operator=(const alert_manager&) = delete;
    alert_manager(alert_manager&&) = delete;
    alert_manager& operator=(alert_manager&&) = delete;
 
    // ========== Lifecycle Management ==========
 
    common::VoidResult start();
 
    common::VoidResult stop();
 
    bool is_running() const;
 
    // ========== Rule Management ==========
 
    common::VoidResult add_rule(std::shared_ptr<alert_rule> rule);
 
    common::VoidResult remove_rule(const std::string& rule_name);
 
    std::shared_ptr<alert_rule> get_rule(const std::string& rule_name) const;
 
    std::vector<std::shared_ptr<alert_rule>> get_rules() const;
 
    common::VoidResult add_rule_group(std::shared_ptr<alert_rule_group> group);
 
    // ========== Alert Operations ==========
 
    common::VoidResult process_metric(const std::string& metric_name, double value);
 
    common::VoidResult process_metrics(const std::unordered_map<std::string, double>& metrics);
 
    std::vector<alert> get_active_alerts() const;
 
    std::optional<alert> get_alert(const std::string& fingerprint) const;
 
    common::VoidResult resolve_alert(const std::string& fingerprint);
 
    // ========== Silence Management ==========
 
    common::Result<uint64_t> create_silence(const alert_silence& silence);
 
    common::VoidResult delete_silence(uint64_t silence_id);
 
    std::vector<alert_silence> get_silences() const;
 
    bool is_silenced(const alert& a) const;
 
    // ========== Notifier Management ==========
 
    common::VoidResult add_notifier(std::shared_ptr<alert_notifier> notifier);
 
    common::VoidResult remove_notifier(const std::string& notifier_name);
 
    std::vector<std::shared_ptr<alert_notifier>> get_notifiers() const;
 
    // ========== Metric Provider ==========
 
    void set_metric_provider(metric_provider_func provider);
 
    // ========== Event Bus Integration ==========
 
    void set_event_bus(std::shared_ptr<interface_event_bus> event_bus);
 
    // ========== Metrics ==========
 
    alert_manager_metrics get_metrics() const;
 
    const alert_manager_config& config() const;
 
private:
    void evaluation_loop();
 
    void evaluate_rule(const std::shared_ptr<alert_rule>& rule, double value);
 
    void update_alert_state(const std::string& fingerprint,
                           bool condition_met,
                           double value,
                           const std::shared_ptr<alert_rule>& rule);
 
    void send_notifications(const alert& a);
 
    void cleanup_silences();
 
    void cleanup_resolved_alerts();
 
    // Configuration
    alert_manager_config config_;
 
    // Rules
    mutable std::mutex rules_mutex_;
    std::unordered_map<std::string, std::shared_ptr<alert_rule>> rules_;
    std::vector<std::shared_ptr<alert_rule_group>> rule_groups_;
 
    // Alerts
    mutable std::mutex alerts_mutex_;
    std::unordered_map<std::string, alert> alerts_;
 
    // Silences
    mutable std::mutex silences_mutex_;
    std::unordered_map<uint64_t, alert_silence> silences_;
 
    // Notifiers
    mutable std::mutex notifiers_mutex_;
    std::vector<std::shared_ptr<alert_notifier>> notifiers_;
 
    // Metric provider
    std::mutex provider_mutex_;
    metric_provider_func metric_provider_;
 
    // Event bus
    std::shared_ptr<interface_event_bus> event_bus_;
 
    // Metrics
    mutable alert_manager_metrics metrics_;
 
    // Evaluation thread
    std::atomic<bool> running_{false};
    std::thread evaluation_thread_;
    std::condition_variable cv_;
    std::mutex cv_mutex_;
 
    // Last notification times
    std::unordered_map<std::string, std::chrono::steady_clock::time_point> last_notification_times_;
};
 
class alert_notifier {
public:
    virtual ~alert_notifier() = default;
 
    virtual std::string name() const = 0;
 
    virtual common::VoidResult notify(const alert& a) = 0;
 
    virtual common::VoidResult notify_group(const alert_group& group) = 0;
 
    virtual bool is_ready() const = 0;
};
 
class log_notifier : public alert_notifier {
public:
    explicit log_notifier(std::string notifier_name = "log_notifier")
        : name_(std::move(notifier_name)) {}
 
    std::string name() const override { return name_; }
 
    common::VoidResult notify(const alert& a) override;
 
    common::VoidResult notify_group(const alert_group& group) override;
 
    bool is_ready() const override { return true; }
 
private:
    std::string name_;
};
 
class callback_notifier : public alert_notifier {
public:
    using callback_func = std::function<void(const alert&)>;
    using group_callback_func = std::function<void(const alert_group&)>;
 
    callback_notifier(std::string notifier_name,
                      callback_func callback,
                      group_callback_func group_callback = nullptr)
        : name_(std::move(notifier_name))
        , callback_(std::move(callback))
        , group_callback_(std::move(group_callback)) {}
 
    std::string name() const override { return name_; }
 
    common::VoidResult notify(const alert& a) override {
        if (callback_) {
            callback_(a);
            return common::ok();
        }
        return common::VoidResult::err(error_info(monitoring_error_code::operation_failed, "No callback configured").to_common_error());
    }
 
    common::VoidResult notify_group(const alert_group& group) override {
        if (group_callback_) {
            group_callback_(group);
            return common::ok();
        }
        // Fall back to individual notifications
        for (const auto& a : group.alerts) {
            auto result = notify(a);
            if (!result.is_ok()) {
                return result;
            }
        }
        return common::ok();
    }
 
    bool is_ready() const override { return callback_ != nullptr; }
 
private:
    std::string name_;
    callback_func callback_;
    group_callback_func group_callback_;
};
 
} // namespace kcenon::monitoring