monitorable_interface.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 <string>
#include <unordered_map>
#include <vector>
#include <chrono>
#include <memory>
#include <any>
#include <optional>
#include <algorithm>
 
namespace kcenon { namespace monitoring {
 
struct monitoring_data {
    using metric_map = std::unordered_map<std::string, double>;
    using tag_map = std::unordered_map<std::string, std::string>;
    
private:
    metric_map metrics_;
    tag_map tags_;
    std::chrono::system_clock::time_point timestamp_;
    std::string component_name_;
    
public:
    monitoring_data()
        : timestamp_(std::chrono::system_clock::now()) {}
    
    explicit monitoring_data(const std::string& name)
        : timestamp_(std::chrono::system_clock::now())
        , component_name_(name) {}
    
    void add_metric(const std::string& key, double value) {
        metrics_[key] = value;
    }
    
    void add_tag(const std::string& key, const std::string& value) {
        tags_[key] = value;
    }
    
    std::optional<double> get_metric(const std::string& key) const {
        auto it = metrics_.find(key);
        if (it != metrics_.end()) {
            return it->second;
        }
        return std::nullopt;
    }
    
    std::optional<std::string> get_tag(const std::string& key) const {
        auto it = tags_.find(key);
        if (it != tags_.end()) {
            return it->second;
        }
        return std::nullopt;
    }
    
    const metric_map& get_metrics() const {
        return metrics_;
    }
    
    const tag_map& get_tags() const {
        return tags_;
    }
    
    std::chrono::system_clock::time_point get_timestamp() const {
        return timestamp_;
    }
    
    const std::string& get_component_name() const {
        return component_name_;
    }
    
    void set_component_name(const std::string& name) {
        component_name_ = name;
    }
    
    void clear() {
        metrics_.clear();
        tags_.clear();
    }
    
    bool empty() const {
        return metrics_.empty() && tags_.empty();
    }
    
    std::size_t metric_count() const {
        return metrics_.size();
    }
    
    std::size_t tag_count() const {
        return tags_.size();
    }
    
    void merge(const monitoring_data& other, const std::string& prefix = "") {
        for (const auto& [key, value] : other.metrics_) {
            if (prefix.empty()) {
                metrics_[key] = value;
            } else {
                metrics_[prefix + "." + key] = value;
            }
        }
        
        for (const auto& [key, value] : other.tags_) {
            if (prefix.empty()) {
                tags_[key] = value;
            } else {
                tags_[prefix + "." + key] = value;
            }
        }
    }
};
 
class monitorable_interface {
public:
    virtual ~monitorable_interface() = default;
    
    virtual common::Result<monitoring_data> get_monitoring_data() const = 0;
    
    virtual std::string get_monitoring_id() const = 0;
    
    virtual bool is_monitoring_enabled() const {
        return true;
    }
    
    virtual common::VoidResult set_monitoring_enabled(bool enable) {
        // Default implementation - can be overridden
        (void)enable; // Suppress unused parameter warning
        return common::ok();
    }
    
    virtual common::VoidResult reset_monitoring() {
        // Default implementation - can be overridden
        return common::ok();
    }
};
 
class monitorable_component : public monitorable_interface {
protected:
    std::string monitoring_id_;
    bool monitoring_enabled_ = true;
    mutable monitoring_data cached_data_;
    
public:
    explicit monitorable_component(const std::string& id)
        : monitoring_id_(id)
        , cached_data_(id) {}
    
    std::string get_monitoring_id() const override {
        return monitoring_id_;
    }
    
    bool is_monitoring_enabled() const override {
        return monitoring_enabled_;
    }
    
    common::VoidResult set_monitoring_enabled(bool enable) override {
        monitoring_enabled_ = enable;
        return common::ok();
    }
    
    common::VoidResult reset_monitoring() override {
        cached_data_.clear();
        cached_data_.set_component_name(monitoring_id_);
        return common::ok();
    }
    
protected:
    void update_metric(const std::string& key, double value) const {
        cached_data_.add_metric(key, value);
    }
    
    void update_tag(const std::string& key, const std::string& value) const {
        cached_data_.add_tag(key, value);
    }
};
 
class monitoring_aggregator {
private:
    std::vector<std::shared_ptr<monitorable_interface>> components_;
    std::string aggregator_id_;
    
public:
    explicit monitoring_aggregator(const std::string& id = "aggregator")
        : aggregator_id_(id) {}
    
    void add_component(std::shared_ptr<monitorable_interface> component) {
        if (component) {
            components_.push_back(component);
        }
    }
    
    bool remove_component(const std::string& id) {
        auto it = std::remove_if(components_.begin(), components_.end(),
            [&id](const auto& comp) {
                return comp->get_monitoring_id() == id;
            });
        
        if (it != components_.end()) {
            components_.erase(it, components_.end());
            return true;
        }
        return false;
    }
    
    common::Result<monitoring_data> collect_all() const {
        monitoring_data aggregated(aggregator_id_);
        
        for (const auto& component : components_) {
            if (!component->is_monitoring_enabled()) {
                continue;
            }
            
            auto result = component->get_monitoring_data();
            if (result.is_ok()) {
                aggregated.merge(result.value(), component->get_monitoring_id());
            } else {
                // Log error but continue with other components
                aggregated.add_tag(
                    component->get_monitoring_id() + ".error",
                    result.error().message
                );
            }
        }
        
        // Add aggregator metadata
        aggregated.add_metric("aggregator.component_count", 
                            static_cast<double>(components_.size()));
        aggregated.add_metric("aggregator.total_metrics", 
                            static_cast<double>(aggregated.metric_count()));
        
        return common::ok(std::move(aggregated));
    }
    
    std::shared_ptr<monitorable_interface> get_component(const std::string& id) const {
        auto it = std::find_if(components_.begin(), components_.end(),
            [&id](const auto& comp) {
                return comp->get_monitoring_id() == id;
            });
        
        return (it != components_.end()) ? *it : nullptr;
    }
    
    std::vector<std::string> get_component_ids() const {
        std::vector<std::string> ids;
        ids.reserve(components_.size());
        
        for (const auto& component : components_) {
            ids.push_back(component->get_monitoring_id());
        }
        
        return ids;
    }
    
    void clear() {
        components_.clear();
    }
    
    std::size_t size() const {
        return components_.size();
    }
};
 
} } // namespace kcenon::monitoring