common_to_monitoring_adapter.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 <memory>
#include <string>
#include <vector>
#include <chrono>
#include "../config/feature_flags.h"
 
#if KCENON_HAS_COMMON_SYSTEM
#include <kcenon/common/interfaces/monitoring_interface.h>
#include <kcenon/common/patterns/result.h>
#endif
 
#include "../interfaces/monitoring_core.h"
#include "../interfaces/monitorable_interface.h"
#include "../core/result_types.h"
 
namespace kcenon { namespace monitoring {
namespace adapters {
 
#if KCENON_HAS_COMMON_SYSTEM
 
class common_system_monitor_adapter : public ::kcenon::common::interfaces::IMonitor {
public:
    explicit common_system_monitor_adapter(
        std::shared_ptr<monitoring_interface> monitor)
        : monitor_(monitor) {}
 
    ~common_system_monitor_adapter() override = default;
 
    ::kcenon::common::VoidResult record_metric(
        const std::string& name,
        double value) override {
        if (!monitor_) {
            return ::kcenon::common::VoidResult(
                ::kcenon::common::error_info(1, "Monitor not initialized", "monitoring_system"));
        }
 
        // Create metric value and add to current collection
        metric_value metric(name, value);
 
        // monitoring_system doesn't have direct record_metric,
        // store locally and include in next collect
        pending_metrics_.push_back(metric);
 
        return ::kcenon::common::VoidResult(std::monostate{});
    }
 
    ::kcenon::common::VoidResult record_metric(
        const std::string& name,
        double value,
        const std::unordered_map<std::string, std::string>& tags) override {
        if (!monitor_) {
            return ::kcenon::common::VoidResult(
                ::kcenon::common::error_info(1, "Monitor not initialized", "monitoring_system"));
        }
 
        metric_value metric(name, value);
        metric.tags = tags;
        pending_metrics_.push_back(metric);
 
        return ::kcenon::common::VoidResult(std::monostate{});
    }
 
    ::kcenon::common::Result<::kcenon::common::interfaces::metrics_snapshot> get_metrics() override {
        if (!monitor_) {
            return ::kcenon::common::error_info(1, "Monitor not initialized", "monitoring_system");
        }
 
        auto result = monitor_->collect_now();
        if (result.is_err()) {
            return ::kcenon::common::error_info(2, "Failed to collect metrics", "monitoring_system");
        }
 
        // Convert monitoring_system snapshot to common snapshot
        ::kcenon::common::interfaces::metrics_snapshot snapshot;
        snapshot.capture_time = result.value().capture_time;
        snapshot.source_id = result.value().source_id;
 
        // Add collected metrics
        for (const auto& m : result.value().metrics) {
            snapshot.metrics.emplace_back(m.name, m.value);
        }
 
        // Add pending metrics
        for (const auto& m : pending_metrics_) {
            snapshot.metrics.push_back(m);
        }
        pending_metrics_.clear();
 
        return snapshot;
    }
 
    ::kcenon::common::Result<::kcenon::common::interfaces::health_check_result> check_health() override {
        if (!monitor_) {
            return ::kcenon::common::error_info(1, "Monitor not initialized", "monitoring_system");
        }
 
        auto result = monitor_->check_health();
        if (result.is_err()) {
            return ::kcenon::common::error_info(2, "Health check failed", "monitoring_system");
        }
 
        // Convert monitoring_system health to common health
        ::kcenon::common::interfaces::health_check_result health;
 
        switch(result.value().status) {
            case health_status::healthy:
                health.status = ::kcenon::common::interfaces::health_status::healthy;
                break;
            case health_status::degraded:
                health.status = ::kcenon::common::interfaces::health_status::degraded;
                break;
            case health_status::unhealthy:
                health.status = ::kcenon::common::interfaces::health_status::unhealthy;
                break;
            default:
                health.status = ::kcenon::common::interfaces::health_status::unknown;
        }
 
        health.message = result.value().message;
        health.timestamp = result.value().timestamp;
        health.check_duration = result.value().check_duration;
        health.metadata = result.value().metadata;
 
        return health;
    }
 
    ::kcenon::common::VoidResult reset() override {
        pending_metrics_.clear();
        // monitoring_system doesn't have direct reset
        return ::kcenon::common::VoidResult(std::monostate{});
    }
 
private:
    std::shared_ptr<monitoring_interface> monitor_;
    std::vector<metric_value> pending_metrics_;
};
 
class monitor_from_common_adapter : public metrics_collector {
public:
    explicit monitor_from_common_adapter(
        std::shared_ptr<::kcenon::common::interfaces::IMonitor> common_monitor,
        const std::string& name = "common_adapter")
        : common_monitor_(common_monitor), name_(name) {}
 
    ~monitor_from_common_adapter() override = default;
 
    common::Result<metrics_snapshot> collect() override {
        if (!common_monitor_) {
            return common::Result<metrics_snapshot>(
                monitoring_error_code::collection_failed,
                "Common monitor not initialized");
        }
 
        auto common_result = common_monitor_->get_metrics();
        if (common_result.is_err()) {
            return common::Result<metrics_snapshot>(
                monitoring_error_code::collection_failed,
                common_result.error().message);
        }
 
        const auto& common_snapshot = common_result.value();
 
        // Convert common snapshot to monitoring_system snapshot
        metrics_snapshot snapshot;
        snapshot.capture_time = common_snapshot.capture_time;
        snapshot.source_id = common_snapshot.source_id;
 
        for (const auto& m : common_snapshot.metrics) {
            snapshot.add_metric(m.name, m.value);
        }
 
        return common::Result<metrics_snapshot>(snapshot);
    }
 
    std::string get_name() const override {
        return name_;
    }
 
    bool is_enabled() const override {
        return enabled_;
    }
 
    common::VoidResult set_enabled(bool enable) override {
        enabled_ = enable;
        return common::ok();
    }
 
    common::VoidResult initialize() override {
        return common::ok();
    }
 
    common::VoidResult cleanup() override {
        if (common_monitor_) {
            common_monitor_->reset();
        }
        return common::ok();
    }
 
private:
    std::shared_ptr<::kcenon::common::interfaces::IMonitor> common_monitor_;
    std::string name_;
    bool enabled_ = true;
};
 
class common_system_monitorable_adapter : public ::kcenon::common::interfaces::IMonitorable {
public:
    explicit common_system_monitorable_adapter(
        std::shared_ptr<monitorable_interface> monitorable,
        const std::string& name = "monitoring_component")
        : monitorable_(monitorable), component_name_(name) {}
 
    ~common_system_monitorable_adapter() override = default;
 
    ::kcenon::common::Result<::kcenon::common::interfaces::metrics_snapshot> get_monitoring_data() override {
        // monitoring_system monitorable doesn't have get_monitoring_data
        // Return empty snapshot
        ::kcenon::common::interfaces::metrics_snapshot snapshot;
        snapshot.source_id = component_name_;
        return snapshot;
    }
 
    ::kcenon::common::Result<::kcenon::common::interfaces::health_check_result> health_check() override {
        // monitoring_system monitorable doesn't have health_check
        // Return healthy status
        ::kcenon::common::interfaces::health_check_result result;
        result.status = ::kcenon::common::interfaces::health_status::healthy;
        result.message = "Component operational";
        return result;
    }
 
    std::string get_component_name() const override {
        return component_name_;
    }
 
private:
    std::shared_ptr<monitorable_interface> monitorable_;
    std::string component_name_;
};
 
class common_monitor_factory {
public:
    static std::shared_ptr<::kcenon::common::interfaces::IMonitor> create_common_monitor(
        std::shared_ptr<monitoring_interface> monitor) {
        return std::make_shared<common_system_monitor_adapter>(monitor);
    }
 
    static std::shared_ptr<metrics_collector> create_from_common(
        std::shared_ptr<::kcenon::common::interfaces::IMonitor> common_monitor,
        const std::string& name = "common_adapter") {
        return std::make_shared<monitor_from_common_adapter>(common_monitor, name);
    }
 
    static std::shared_ptr<::kcenon::common::interfaces::IMonitorable> create_common_monitorable(
        std::shared_ptr<monitorable_interface> monitorable,
        const std::string& name = "monitoring_component") {
        return std::make_shared<common_system_monitorable_adapter>(monitorable, name);
    }
};
 
#endif // KCENON_HAS_COMMON_SYSTEM
 
} // namespace adapters
} } // namespace kcenon::monitoring