monitoring_interface.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <string>
#include <unordered_map>
#include <vector>
#include <chrono>
#include <atomic>
#include <kcenon/logger/core/error_codes.h>
 
namespace kcenon::logger {
 
enum class health_status {
    healthy,        
    degraded,       
    unhealthy,      
    unknown         
};
 
enum class metric_type {
    counter,        
    gauge,          
    histogram,      
    summary         
};
 
struct metric_value {
    std::string name;
    double value;
    metric_type type;
    std::chrono::system_clock::time_point timestamp;
    std::unordered_map<std::string, std::string> labels;
    
    metric_value() : value(0.0), type(metric_type::gauge),
                    timestamp(std::chrono::system_clock::now()) {}
    
    metric_value(const std::string& n, double v, metric_type t = metric_type::gauge)
        : name(n), value(v), type(t), 
          timestamp(std::chrono::system_clock::now()) {}
};
 
class monitoring_data {
private:
    std::vector<metric_value> metrics_;
    std::chrono::system_clock::time_point collection_time_;
    
public:
    monitoring_data() : collection_time_(std::chrono::system_clock::now()) {}
    
    void add_metric(const std::string& name, double value, 
                   metric_type type = metric_type::gauge) {
        metrics_.emplace_back(name, value, type);
    }
    
    void add_metric(const metric_value& metric) {
        metrics_.push_back(metric);
    }
    
    const std::vector<metric_value>& get_metrics() const {
        return metrics_;
    }
    
    std::chrono::system_clock::time_point get_collection_time() const {
        return collection_time_;
    }
    
    void clear() {
        metrics_.clear();
    }
    
    size_t size() const {
        return metrics_.size();
    }
};
 
class health_check_result {
private:
    health_status status_;
    std::string message_;
    std::vector<std::string> issues_;
    std::chrono::system_clock::time_point check_time_;
    
public:
    health_check_result(health_status status = health_status::healthy)
        : status_(status), check_time_(std::chrono::system_clock::now()) {}
    
    void set_status(health_status status) {
        status_ = status;
    }
    
    health_status get_status() const {
        return status_;
    }
    
    void add_issue(const std::string& issue) {
        issues_.push_back(issue);
        // Automatically degrade status when issues are added
        if (status_ == health_status::healthy) {
            status_ = health_status::degraded;
        }
    }
    
    const std::vector<std::string>& get_issues() const {
        return issues_;
    }
    
    void set_message(const std::string& message) {
        message_ = message;
    }
    
    const std::string& get_message() const {
        return message_;
    }
    
    bool is_healthy() const {
        return status_ == health_status::healthy;
    }
    
    std::chrono::system_clock::time_point get_check_time() const {
        return check_time_;
    }
};
 
class monitoring_interface {
public:
    virtual ~monitoring_interface() = default;
    
    virtual result<monitoring_data> collect_metrics() const = 0;
    
    virtual result<health_check_result> check_health() const = 0;
    
    virtual common::VoidResult reset_metrics() = 0;
 
    virtual common::VoidResult set_enabled(bool enable) = 0;
    
    virtual bool is_enabled() const = 0;
    
    virtual std::string get_backend_name() const = 0;
    
    virtual void increment_counter(const std::string& name, double value = 1.0) = 0;
    
    virtual void update_gauge(const std::string& name, double value) = 0;
    
    virtual void record_histogram(const std::string& name, double value) = 0;
};
 
inline std::string health_status_to_string(health_status status) {
    switch (status) {
        case health_status::healthy:
            return "healthy";
        case health_status::degraded:
            return "degraded";
        case health_status::unhealthy:
            return "unhealthy";
        case health_status::unknown:
            return "unknown";
        default:
            return "unknown";
    }
}
 
inline std::string metric_type_to_string(metric_type type) {
    switch (type) {
        case metric_type::counter:
            return "counter";
        case metric_type::gauge:
            return "gauge";
        case metric_type::histogram:
            return "histogram";
        case metric_type::summary:
            return "summary";
        default:
            return "unknown";
    }
}
 
} // namespace kcenon::logger