alert_types.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 <algorithm>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <optional>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
 
namespace kcenon::monitoring {
 
enum class alert_severity : uint8_t {
    info = 0,       
    warning,        
    critical,       
    emergency       
};
 
constexpr const char* alert_severity_to_string(alert_severity severity) noexcept {
    switch (severity) {
        case alert_severity::info:      return "info";
        case alert_severity::warning:   return "warning";
        case alert_severity::critical:  return "critical";
        case alert_severity::emergency: return "emergency";
        default:                        return "unknown";
    }
}
 
enum class alert_state : uint8_t {
    inactive = 0,   
    pending,        
    firing,         
    resolved,       
    suppressed      
};
 
constexpr const char* alert_state_to_string(alert_state state) noexcept {
    switch (state) {
        case alert_state::inactive:   return "inactive";
        case alert_state::pending:    return "pending";
        case alert_state::firing:     return "firing";
        case alert_state::resolved:   return "resolved";
        case alert_state::suppressed: return "suppressed";
        default:                      return "unknown";
    }
}
 
struct alert_labels {
    std::unordered_map<std::string, std::string> labels;
 
    alert_labels() = default;
 
    explicit alert_labels(std::unordered_map<std::string, std::string> lbl)
        : labels(std::move(lbl)) {}
 
    void set(const std::string& key, const std::string& value) {
        labels[key] = value;
    }
 
    std::string get(const std::string& key) const {
        auto it = labels.find(key);
        return it != labels.end() ? it->second : "";
    }
 
    bool has(const std::string& key) const {
        return labels.find(key) != labels.end();
    }
 
    std::string fingerprint() const {
        std::string result;
        std::vector<std::pair<std::string, std::string>> sorted_labels(
            labels.begin(), labels.end());
        std::sort(sorted_labels.begin(), sorted_labels.end());
        for (const auto& [key, value] : sorted_labels) {
            result += key + "=" + value + ",";
        }
        return result;
    }
 
    bool operator==(const alert_labels& other) const {
        return labels == other.labels;
    }
};
 
struct alert_annotations {
    std::string summary;                                        
    std::string description;                                    
    std::optional<std::string> runbook_url;                     
    std::unordered_map<std::string, std::string> custom;        
 
    alert_annotations() = default;
 
    alert_annotations(std::string sum, std::string desc)
        : summary(std::move(sum)), description(std::move(desc)) {}
};
 
struct alert {
    std::string name;                                           
    alert_labels labels;                                        
    alert_annotations annotations;                              
    alert_severity severity = alert_severity::warning;          
    alert_state state = alert_state::inactive;                  
    double value = 0.0;                                         
 
    std::chrono::steady_clock::time_point created_at;           
    std::chrono::steady_clock::time_point updated_at;           
    std::optional<std::chrono::steady_clock::time_point> started_at;  
    std::optional<std::chrono::steady_clock::time_point> resolved_at; 
 
    uint64_t id = 0;                                            
    std::string rule_name;                                      
    std::string group_key;                                      
 
    alert()
        : created_at(std::chrono::steady_clock::now())
        , updated_at(created_at)
        , id(generate_id()) {}
 
    alert(std::string alert_name, alert_labels lbl)
        : name(std::move(alert_name))
        , labels(std::move(lbl))
        , created_at(std::chrono::steady_clock::now())
        , updated_at(created_at)
        , id(generate_id()) {}
 
    std::string fingerprint() const {
        return name + "{" + labels.fingerprint() + "}";
    }
 
    bool is_active() const {
        return state == alert_state::pending || state == alert_state::firing;
    }
 
    std::chrono::steady_clock::duration state_duration() const {
        return std::chrono::steady_clock::now() - updated_at;
    }
 
    std::chrono::steady_clock::duration firing_duration() const {
        if (state == alert_state::firing && started_at.has_value()) {
            return std::chrono::steady_clock::now() - *started_at;
        }
        return std::chrono::steady_clock::duration::zero();
    }
 
    bool transition_to(alert_state new_state) {
        if (!is_valid_transition(state, new_state)) {
            return false;
        }
 
        auto now = std::chrono::steady_clock::now();
        state = new_state;
        updated_at = now;
 
        if (new_state == alert_state::firing && !started_at.has_value()) {
            started_at = now;
        } else if (new_state == alert_state::resolved) {
            resolved_at = now;
        }
 
        return true;
    }
 
private:
    static uint64_t generate_id() {
        static std::atomic<uint64_t> counter{0};
        return counter.fetch_add(1, std::memory_order_relaxed);
    }
 
    static bool is_valid_transition(alert_state from, alert_state to) {
        // All transitions are valid from suppressed (when silence expires)
        if (from == alert_state::suppressed) {
            return true;
        }
 
        // Transition to suppressed is always valid
        if (to == alert_state::suppressed) {
            return true;
        }
 
        switch (from) {
            case alert_state::inactive:
                return to == alert_state::pending;
            case alert_state::pending:
                return to == alert_state::firing || to == alert_state::inactive;
            case alert_state::firing:
                return to == alert_state::resolved;
            case alert_state::resolved:
                return to == alert_state::pending || to == alert_state::inactive;
            default:
                return false;
        }
    }
};
 
struct alert_group {
    std::string group_key;                                      
    std::vector<alert> alerts;                                  
    std::chrono::steady_clock::time_point created_at;           
    std::chrono::steady_clock::time_point updated_at;           
    alert_labels common_labels;                                 
 
    alert_group()
        : created_at(std::chrono::steady_clock::now())
        , updated_at(created_at) {}
 
    explicit alert_group(std::string key)
        : group_key(std::move(key))
        , created_at(std::chrono::steady_clock::now())
        , updated_at(created_at) {}
 
    void add_alert(alert a) {
        alerts.push_back(std::move(a));
        updated_at = std::chrono::steady_clock::now();
    }
 
    size_t size() const {
        return alerts.size();
    }
 
    bool empty() const {
        return alerts.empty();
    }
 
    alert_severity max_severity() const {
        alert_severity max_sev = alert_severity::info;
        for (const auto& a : alerts) {
            if (static_cast<uint8_t>(a.severity) > static_cast<uint8_t>(max_sev)) {
                max_sev = a.severity;
            }
        }
        return max_sev;
    }
};
 
struct alert_silence {
    uint64_t id = 0;                                            
    std::string comment;                                        
    std::string created_by;                                     
    alert_labels matchers;                                      
    std::chrono::steady_clock::time_point starts_at;            
    std::chrono::steady_clock::time_point ends_at;              
 
    alert_silence()
        : id(generate_id())
        , starts_at(std::chrono::steady_clock::now())
        , ends_at(starts_at + std::chrono::hours(1)) {}
 
    bool is_active() const {
        auto now = std::chrono::steady_clock::now();
        return now >= starts_at && now < ends_at;
    }
 
    bool matches(const alert& a) const {
        if (!is_active()) {
            return false;
        }
 
        // All matcher labels must be present in alert labels
        for (const auto& [key, value] : matchers.labels) {
            if (a.labels.get(key) != value) {
                return false;
            }
        }
        return true;
    }
 
private:
    static uint64_t generate_id() {
        static std::atomic<uint64_t> counter{0};
        return counter.fetch_add(1, std::memory_order_relaxed);
    }
};
 
} // namespace kcenon::monitoring