observability_bridge.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
#ifndef KCENON_NETWORK_INTERNAL_INTEGRATION_OBSERVABILITY_BRIDGE_H_
#define KCENON_NETWORK_INTERNAL_INTEGRATION_OBSERVABILITY_BRIDGE_H_
 
#include "internal/integration/bridge_interface.h"
#include "internal/integration/logger_integration.h"
#include "internal/integration/monitoring_integration.h"
#include <kcenon/network/detail/config/feature_flags.h>
#include <memory>
#include <mutex>
#include <atomic>
 
#if KCENON_WITH_COMMON_SYSTEM
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
#endif
 
namespace kcenon::network::integration {
 
class ObservabilityBridge : public INetworkBridge {
public:
    enum class BackendType {
        CommonSystem,  
        Standalone     
    };
 
    explicit ObservabilityBridge(
        std::shared_ptr<logger_interface> logger,
        std::shared_ptr<monitoring_interface> monitor,
        BackendType backend_type = BackendType::Standalone);
 
    ~ObservabilityBridge() override;
 
    // INetworkBridge interface implementation
 
    VoidResult initialize(const BridgeConfig& config) override;
 
    VoidResult shutdown() override;
 
    bool is_initialized() const override;
 
    BridgeMetrics get_metrics() const override;
 
    // ObservabilityBridge-specific methods
 
    std::shared_ptr<logger_interface> get_logger() const;
 
    std::shared_ptr<monitoring_interface> get_monitor() const;
 
    BackendType get_backend_type() const;
 
    // Factory methods
 
#if KCENON_WITH_COMMON_SYSTEM
    static std::shared_ptr<ObservabilityBridge> from_common_system(
        std::shared_ptr<::kcenon::common::interfaces::ILogger> logger,
        std::shared_ptr<::kcenon::common::interfaces::IMonitor> monitor);
#endif
 
private:
    std::shared_ptr<logger_interface> logger_;
    std::shared_ptr<monitoring_interface> monitor_;
    BackendType backend_type_;
    std::atomic<bool> initialized_{false};
    mutable std::mutex metrics_mutex_;
    mutable BridgeMetrics cached_metrics_;
    bool monitoring_enabled_{true};
};
 
} // namespace kcenon::network::integration
 
// Backward compatibility namespace alias
namespace network_system {
    namespace integration = kcenon::network::integration;
}
 
#endif // KCENON_NETWORK_INTERNAL_INTEGRATION_OBSERVABILITY_BRIDGE_H_