monitoring_backend.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 "integration_backend.h"
#include <kcenon/logger/core/monitoring_integration_detector.h>
#include <memory>
#include <string>
 
// Conditional includes based on integration settings
#ifdef ENABLE_MONITORING_INTEGRATION
#include <kcenon/monitoring/interfaces/monitoring_interface.h>
#endif
 
namespace kcenon::logger::backends {
 
#ifdef ENABLE_MONITORING_INTEGRATION
 
class monitoring_backend : public integration_backend {
public:
    explicit monitoring_backend(
        std::shared_ptr<monitoring::interfaces::IMonitor> monitor = nullptr)
        : monitor_(std::move(monitor)) {}
 
    ~monitoring_backend() override = default;
 
    log_level normalize_level(int external_level) const override {
        // monitoring_system uses same level scheme as common::interfaces::log_level
        return static_cast<log_level>(external_level);
    }
 
    std::string get_backend_name() const override {
        return "monitoring_system";
    }
 
    bool requires_initialization() const override {
        return monitor_ != nullptr;
    }
 
    bool initialize() override {
        if (!monitor_) {
            return true; // No monitor, nothing to initialize
        }
 
        // Register logger metrics with monitoring system
        // This would typically set up metric collectors, event subscriptions, etc.
        // Implementation depends on monitoring_system's API
 
        return true;
    }
 
    void shutdown() override {
        if (!monitor_) {
            return;
        }
 
        // Flush any pending metrics
        // Unregister from monitoring system
        // Implementation depends on monitoring_system's API
    }
 
    void emit_metric(const std::string& metric_name, double value) {
        if (!monitor_) {
            return;
        }
 
        // Emit metric to monitoring system
        // Implementation would call monitor_->record_metric(metric_name, value)
        // or similar API depending on monitoring_system's interface
    }
 
    void publish_event(const std::string& event_type, const std::string& event_data) {
        if (!monitor_) {
            return;
        }
 
        // Publish event to monitoring system
        // Implementation would call monitor_->publish_event(event_type, event_data)
        // or similar API depending on monitoring_system's interface
    }
 
private:
    std::shared_ptr<monitoring::interfaces::IMonitor> monitor_;
};
 
#endif // ENABLE_MONITORING_INTEGRATION
 
} // namespace kcenon::logger::backends