monitoring_core.h

Go to the documentation of this file.

#pragma once
 
// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
 
#include "../core/result_types.h"
#include "../core/error_codes.h"
#include <memory>
#include <string>
#include <vector>
#include <chrono>
#include <functional>
#include <unordered_map>
#include <optional>
#include <exception>
 
namespace kcenon { namespace monitoring {
 
// Forward declarations
class metrics_collector;
class storage_backend;
class metrics_analyzer;
struct metrics_snapshot;
struct monitoring_config;
struct health_check_result;
 
struct metric_value {
    std::string name;
    double value;
    std::chrono::system_clock::time_point timestamp;
    std::unordered_map<std::string, std::string> tags;
    
    metric_value(const std::string& n = "", double v = 0.0)
        : name(n)
        , value(v)
        , timestamp(std::chrono::system_clock::now()) {}
};
 
struct metrics_snapshot {
    std::vector<metric_value> metrics;
    std::chrono::system_clock::time_point capture_time;
    std::string source_id;
    
    metrics_snapshot()
        : capture_time(std::chrono::system_clock::now()) {}
    
    void add_metric(const std::string& name, double value) {
        metrics.emplace_back(name, value);
    }
 
    void add_metric(const std::string& name, double value,
                   const std::unordered_map<std::string, std::string>& tags) {
        metric_value mv(name, value);
        mv.tags = tags;
        metrics.push_back(std::move(mv));
    }
    
    std::optional<double> get_metric(const std::string& name) const {
        for (const auto& m : metrics) {
            if (m.name == name) {
                return m.value;
            }
        }
        return std::nullopt;
    }
};
 
enum class health_status {
    healthy,
    degraded,
    unhealthy,
    unknown
};
 
struct health_check_result {
    health_status status = health_status::unknown;
    std::string message;
    std::vector<std::string> issues;
    std::chrono::system_clock::time_point check_time;
    std::chrono::system_clock::time_point timestamp;
    std::chrono::milliseconds check_duration{0};
    std::unordered_map<std::string, std::string> metadata;
    std::optional<std::exception_ptr> error;
    
    health_check_result()
        : check_time(std::chrono::system_clock::now()),
          timestamp(std::chrono::system_clock::now()) {}
    
    bool is_healthy() const {
        return status == health_status::healthy;
    }
    
    bool is_operational() const {
        return status == health_status::healthy || 
               status == health_status::degraded;
    }
    
    static health_check_result healthy(const std::string& msg = "OK") {
        health_check_result result;
        result.status = health_status::healthy;
        result.message = msg;
        result.timestamp = std::chrono::system_clock::now();
        result.check_time = result.timestamp;
        return result;
    }
    
    static health_check_result unhealthy(const std::string& msg) {
        health_check_result result;
        result.status = health_status::unhealthy;
        result.message = msg;
        result.timestamp = std::chrono::system_clock::now();
        result.check_time = result.timestamp;
        return result;
    }
    
    static health_check_result degraded(const std::string& msg) {
        health_check_result result;
        result.status = health_status::degraded;
        result.message = msg;
        result.timestamp = std::chrono::system_clock::now();
        result.check_time = result.timestamp;
        return result;
    }
};
 
struct monitoring_config {
    std::size_t history_size = 1000;
    std::chrono::milliseconds collection_interval{1000};
    bool enable_compression = false;
    bool enable_persistence = false;
    std::size_t max_collectors = 100;
    std::size_t buffer_size = 10000;
    
    common::VoidResult validate() const {
        if (history_size == 0) {
            error_info err(monitoring_error_code::invalid_capacity,
                          "History size must be greater than 0");
            return common::VoidResult::err(err.to_common_error());
        }
        if (collection_interval.count() < 10) {
            error_info err(monitoring_error_code::invalid_interval,
                          "Collection interval must be at least 10ms");
            return common::VoidResult::err(err.to_common_error());
        }
        if (buffer_size < history_size) {
            error_info err(monitoring_error_code::invalid_capacity,
                          "Buffer size must be at least as large as history size");
            return common::VoidResult::err(err.to_common_error());
        }
        return common::ok();
    }
};
 
class monitoring_interface {
public:
    virtual ~monitoring_interface() = default;
 
    // Configuration
    virtual common::VoidResult configure(const monitoring_config& config) = 0;
    virtual common::Result<monitoring_config> get_configuration() const = 0;
 
    // Collector management
    virtual common::VoidResult add_collector(std::unique_ptr<metrics_collector> collector) = 0;
    virtual common::VoidResult remove_collector(const std::string& name) = 0;
    virtual common::Result<std::vector<std::string>> list_collectors() const = 0;
 
    // Metrics operations
    virtual common::VoidResult start() = 0;
    virtual common::VoidResult stop() = 0;
    virtual common::Result<metrics_snapshot> collect_now() = 0;
    virtual common::Result<metrics_snapshot> get_latest_snapshot() const = 0;
    virtual common::Result<std::vector<metrics_snapshot>> get_history(std::size_t count) const = 0;
 
    // Health checks
    virtual common::Result<health_check_result> check_health() const = 0;
    virtual common::VoidResult register_health_check(
        const std::string& name,
        std::function<health_check_result()> checker) = 0;
 
    // Storage management
    virtual common::VoidResult set_storage_backend(std::unique_ptr<storage_backend> storage) = 0;
    virtual common::VoidResult flush_storage() = 0;
 
    // Analysis
    virtual common::VoidResult add_analyzer(std::unique_ptr<metrics_analyzer> analyzer) = 0;
    virtual common::Result<std::vector<std::string>> get_analysis_results() const = 0;
 
    // Status
    virtual bool is_running() const = 0;
    virtual common::Result<std::string> get_status_summary() const = 0;
};
 
class metrics_collector {
public:
    virtual ~metrics_collector() = default;
 
    virtual common::Result<metrics_snapshot> collect() = 0;
 
    virtual std::string get_name() const = 0;
 
    virtual bool is_enabled() const = 0;
 
    virtual common::VoidResult set_enabled(bool enable) = 0;
 
    virtual common::VoidResult initialize() = 0;
 
    virtual common::VoidResult cleanup() = 0;
};
 
class storage_backend {
public:
    virtual ~storage_backend() = default;
 
    virtual common::VoidResult store(const metrics_snapshot& snapshot) = 0;
 
    virtual common::Result<metrics_snapshot> retrieve(std::size_t index) const = 0;
 
    virtual common::Result<std::vector<metrics_snapshot>> retrieve_range(
        std::size_t start_index, std::size_t count) const = 0;
 
    virtual std::size_t capacity() const = 0;
 
    virtual std::size_t size() const = 0;
 
    virtual common::VoidResult clear() = 0;
 
    virtual common::VoidResult flush() = 0;
};
 
class metrics_analyzer {
public:
    virtual ~metrics_analyzer() = default;
 
    virtual common::Result<std::string> analyze(const metrics_snapshot& snapshot) = 0;
 
    virtual common::Result<std::string> analyze_trend(
        const std::vector<metrics_snapshot>& snapshots) = 0;
 
    virtual std::string get_name() const = 0;
 
    virtual common::VoidResult reset() = 0;
};
 
} } // namespace kcenon::monitoring