logger_to_monitoring_adapter.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef KCENON_MONITORING_ADAPTERS_LOGGER_TO_MONITORING_ADAPTER_H
#define KCENON_MONITORING_ADAPTERS_LOGGER_TO_MONITORING_ADAPTER_H
 
// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
 
// Module description:
// Logger system adapter for monitoring_system (Phase 2.3.3).
// Uses common_system interfaces for logger integration via dependency injection.
// No direct dependency on logger_system - works with any ILogger implementation.
 
#include <atomic>
#include <chrono>
#include <memory>
#include <optional>
#include <string>
#include <thread>
#include <vector>
 
#include "../core/event_bus.h"
#include "../core/event_types.h"
#include "../core/result_types.h"
#include "../interfaces/metric_types_adapter.h"
 
// Use common_system interfaces for logger integration (Phase 2.3.3)
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
 
namespace kcenon { namespace monitoring {
 
class logger_to_monitoring_adapter {
public:
    explicit logger_to_monitoring_adapter(
        std::shared_ptr<event_bus> bus,
        std::shared_ptr<common::interfaces::ILogger> logger = nullptr
    ) : bus_(std::move(bus)), logger_(std::move(logger)) {}
 
    bool is_logger_system_available() const {
        return logger_ != nullptr;
    }
 
    void set_logger(std::shared_ptr<common::interfaces::ILogger> logger) {
        logger_ = std::move(logger);
    }
 
    std::shared_ptr<common::interfaces::ILogger> get_logger() const {
        return logger_;
    }
 
    common::Result<std::vector<metric>> collect_metrics() {
        std::vector<metric> out;
        if (logger_) {
            // If logger implements IMonitorable, collect its metrics
            auto monitorable = std::dynamic_pointer_cast<common::interfaces::IMonitorable>(logger_);
            if (monitorable) {
                auto metrics_result = monitorable->get_monitoring_data();
                if (metrics_result.is_ok()) {
                    const auto& snapshot = metrics_result.value();
                    // Convert to monitoring_system metric format
                    for (const auto& m : snapshot.metrics) {
                        metric converted;
                        converted.name = m.name;
                        converted.value = m.value;
                        converted.timestamp = m.timestamp;
                        out.push_back(converted);
                    }
                }
            }
        }
        return common::ok(std::move(out));
    }
 
    common::VoidResult register_logger(const std::string& /*name*/) {
        // Logger is now provided via DI, not registered by name
        return common::ok();
    }
 
    double get_current_log_rate() const {
        if (logger_) {
            auto monitorable = std::dynamic_pointer_cast<common::interfaces::IMonitorable>(logger_);
            if (monitorable) {
                auto metrics_result = monitorable->get_monitoring_data();
                if (metrics_result.is_ok()) {
                    const auto& snapshot = metrics_result.value();
                    for (const auto& m : snapshot.metrics) {
                        if (m.name.find("messages_logged") != std::string::npos ||
                            m.name.find("log_rate") != std::string::npos) {
                            return m.value;
                        }
                    }
                }
            }
        }
        return 0.0;
    }
 
private:
    std::shared_ptr<event_bus> bus_;
    std::shared_ptr<common::interfaces::ILogger> logger_;  // Phase 2.3.3
};
 
} } // namespace kcenon::monitoring
 
#endif // KCENON_MONITORING_ADAPTERS_LOGGER_TO_MONITORING_ADAPTER_H