Bridge for observability (logger + monitoring) integration implementing INetworkBridge. More...

#include <observability_bridge.h>

Inheritance diagram for kcenon::network::integration::ObservabilityBridge:

Collaboration diagram for kcenon::network::integration::ObservabilityBridge:

Public Types
enum class	BackendType { CommonSystem , Standalone }
	Type of observability backend. More...

Public Member Functions
	ObservabilityBridge (std::shared_ptr< logger_interface > logger, std::shared_ptr< monitoring_interface > monitor, BackendType backend_type=BackendType::Standalone)
	Construct bridge with logger and monitoring interfaces.

	~ObservabilityBridge () override
	Destructor.

VoidResult	initialize (const BridgeConfig &config) override
	Initialize the bridge with configuration.

VoidResult	shutdown () override
	Shutdown the bridge.

bool	is_initialized () const override
	Check if the bridge is initialized.

BridgeMetrics	get_metrics () const override
	Get current metrics.

std::shared_ptr< logger_interface >	get_logger () const
	Get the logger interface.

std::shared_ptr< monitoring_interface >	get_monitor () const
	Get the monitoring interface.

BackendType	get_backend_type () const
	Get the backend type.

Public Member Functions inherited from kcenon::network::integration::INetworkBridge
virtual	~INetworkBridge ()=default

Private Attributes
std::shared_ptr< logger_interface >	logger_

std::shared_ptr< monitoring_interface >	monitor_

BackendType	backend_type_

std::atomic< bool >	initialized_ {false}

std::mutex	metrics_mutex_

BridgeMetrics	cached_metrics_

bool	monitoring_enabled_ {true}

Detailed Description

Bridge for observability (logger + monitoring) integration implementing INetworkBridge.

This class consolidates logger and monitoring integrations into a single, unified bridge. It provides factory methods for creating bridges from different backend types.

Backend Types:

CommonSystem: Uses common_system's ILogger and IMonitor (when KCENON_WITH_COMMON_SYSTEM)
Standalone: Uses network_system's logger_interface and monitoring_interface

Lifecycle:

Create using factory method (from_common_system) or direct constructor
Call initialize() with configuration
Use get_logger() and get_monitor() to access observability interfaces
Call shutdown() before destruction

Thread Safety:

initialize() and shutdown() are not thread-safe (single-threaded usage)
get_metrics() is thread-safe for concurrent queries
get_logger() and get_monitor() are thread-safe after initialization

Definition at line 83 of file observability_bridge.h.

Member Enumeration Documentation

◆ BackendType

enum class kcenon::network::integration::ObservabilityBridge::BackendType

strong

Type of observability backend.

Enumerator
CommonSystem	Uses common_system's ILogger and IMonitor.
Standalone	Uses network_system's logger_interface and monitoring_interface.

Definition at line 89 of file observability_bridge.h.

                           {
        CommonSystem,  
        Standalone     
    };

Constructor & Destructor Documentation

◆ ObservabilityBridge()

kcenon::network::integration::ObservabilityBridge::ObservabilityBridge	(	std::shared_ptr< logger_interface >	logger,
		std::shared_ptr< monitoring_interface >	monitor,
		BackendType	backend_type = BackendType::Standalone )

explicit

Construct bridge with logger and monitoring interfaces.

Parameters

logger	Logger implementation
monitor	Monitoring implementation
backend_type	Type of backend (default: Standalone)

Exceptions

std::invalid_argument if logger or monitor is nullptr

Example:

auto logger = std::make_shared<basic_logger>();
auto monitor = std::make_shared<basic_monitoring>();
auto bridge = std::make_shared<ObservabilityBridge>(logger, monitor);

Definition at line 10 of file observability_bridge.cpp.

    : logger_(std::move(logger))
    , monitor_(std::move(monitor))
    , backend_type_(backend_type) {
    if (!logger_) {
        throw std::invalid_argument("ObservabilityBridge requires non-null logger");
    }
    if (!monitor_) {
        throw std::invalid_argument("ObservabilityBridge requires non-null monitor");
    }
}

References logger_, and monitor_.

◆ ~ObservabilityBridge()

kcenon::network::integration::ObservabilityBridge::~ObservabilityBridge ( )

override

Destructor.

Automatically calls shutdown() if initialized

Definition at line 25 of file observability_bridge.cpp.

                                          {
    if (initialized_.load()) {
        shutdown();
    }
}

References initialized_, and shutdown().

Here is the call graph for this function:

Member Function Documentation

◆ get_backend_type()

ObservabilityBridge::BackendType kcenon::network::integration::ObservabilityBridge::get_backend_type ( ) const

Get the backend type.

Returns: Type of backend this bridge uses

Definition at line 142 of file observability_bridge.cpp.

                                                                           {
    return backend_type_;
}

References backend_type_.

◆ get_logger()

std::shared_ptr< logger_interface > kcenon::network::integration::ObservabilityBridge::get_logger ( ) const

Get the logger interface.

Returns: Shared pointer to logger, or nullptr if not initialized

Thread Safety: Safe to call after initialization

Example:

if (auto logger = bridge->get_logger()) {
    logger->log(log_level::info, "Application started");
}

Definition at line 134 of file observability_bridge.cpp.

                                                                      {
    return logger_;
}

References logger_.

◆ get_metrics()

BridgeMetrics kcenon::network::integration::ObservabilityBridge::get_metrics ( ) const

overridevirtual

Get current metrics.

Returns: Bridge metrics including observability statistics

Custom Metrics:

"backend_type": Backend type (0=CommonSystem, 1=Standalone)
"monitoring_enabled": 1.0 if monitoring is enabled, 0.0 otherwise
"logger_available": 1.0 if logger is available, 0.0 otherwise
"monitor_available": 1.0 if monitor is available, 0.0 otherwise

Thread Safety: Safe to call concurrently

Implements kcenon::network::integration::INetworkBridge.

Definition at line 109 of file observability_bridge.cpp.

                                                     {
    std::lock_guard<std::mutex> lock(metrics_mutex_);
 
    if (!initialized_.load() || !logger_ || !monitor_) {
        BridgeMetrics metrics;
        metrics.is_healthy = false;
        metrics.last_activity = cached_metrics_.last_activity;
        return metrics;
    }
 
    // Update metrics with current state
    BridgeMetrics metrics = cached_metrics_;
    metrics.is_healthy = (logger_ && monitor_);
    metrics.last_activity = std::chrono::steady_clock::now();
    metrics.custom_metrics["backend_type"] = static_cast<double>(backend_type_);
    metrics.custom_metrics["monitoring_enabled"] = monitoring_enabled_ ? 1.0 : 0.0;
    metrics.custom_metrics["logger_available"] = logger_ ? 1.0 : 0.0;
    metrics.custom_metrics["monitor_available"] = monitor_ ? 1.0 : 0.0;
 
    // Update cached metrics for next call
    cached_metrics_ = metrics;
 
    return metrics;
}

References backend_type_, cached_metrics_, kcenon::network::integration::BridgeMetrics::custom_metrics, initialized_, kcenon::network::integration::BridgeMetrics::is_healthy, kcenon::network::integration::BridgeMetrics::last_activity, logger_, metrics_mutex_, monitor_, and monitoring_enabled_.

◆ get_monitor()

std::shared_ptr< monitoring_interface > kcenon::network::integration::ObservabilityBridge::get_monitor ( ) const

Get the monitoring interface.

Returns: Shared pointer to monitoring interface, or nullptr if not initialized

Thread Safety: Safe to call after initialization

Example:

if (auto monitor = bridge->get_monitor()) {
    monitor->report_counter("requests_total", 1);
}

Definition at line 138 of file observability_bridge.cpp.

                                                                           {
    return monitor_;
}

References monitor_.

◆ initialize()

VoidResult kcenon::network::integration::ObservabilityBridge::initialize ( const BridgeConfig & config )

overridevirtual

Initialize the bridge with configuration.

Parameters

config Configuration parameters

Returns: ok() on success, error_info on failure

Configuration Properties:

"enabled": "true" or "false" (default: "true")
"log_level": Minimum log level (informational)
"enable_monitoring": Enable/disable monitoring (default: "true")

Error Conditions:

Already initialized
Logger or monitor is null
Invalid configuration

Example:

BridgeConfig config;
config.integration_name = "common_system";
config.properties["log_level"] = "info";
config.properties["enable_monitoring"] = "true";
 
auto result = bridge->initialize(config);
if (result.is_err()) {
    std::cerr << "Init failed: " << result.error().message << std::endl;
}

Implements kcenon::network::integration::INetworkBridge.

Definition at line 31 of file observability_bridge.cpp.

                                                                     {
    if (initialized_.load()) {
        return error_void(
            error_codes::common_errors::already_exists,
            "ObservabilityBridge already initialized",
            "ObservabilityBridge::initialize");
    }
 
    if (!logger_) {
        return error_void(
            error_codes::common_errors::invalid_argument,
            "Logger is null",
            "ObservabilityBridge::initialize");
    }
 
    if (!monitor_) {
        return error_void(
            error_codes::common_errors::invalid_argument,
            "Monitor is null",
            "ObservabilityBridge::initialize");
    }
 
    // Check if bridge is enabled (default: true)
    auto enabled_it = config.properties.find("enabled");
    if (enabled_it != config.properties.end() && enabled_it->second == "false") {
        return error_void(
            error_codes::common_errors::invalid_argument,
            "Bridge is disabled in configuration",
            "ObservabilityBridge::initialize");
    }
 
    // Check if monitoring is enabled (default: true)
    auto monitoring_enabled_it = config.properties.find("enable_monitoring");
    monitoring_enabled_ = (monitoring_enabled_it == config.properties.end() ||
                          monitoring_enabled_it->second != "false");
 
    // Initialize metrics
    std::lock_guard<std::mutex> lock(metrics_mutex_);
    cached_metrics_.is_healthy = true;
    cached_metrics_.last_activity = std::chrono::steady_clock::now();
    cached_metrics_.custom_metrics["backend_type"] = static_cast<double>(backend_type_);
    cached_metrics_.custom_metrics["monitoring_enabled"] = monitoring_enabled_ ? 1.0 : 0.0;
    cached_metrics_.custom_metrics["logger_available"] = logger_ ? 1.0 : 0.0;
    cached_metrics_.custom_metrics["monitor_available"] = monitor_ ? 1.0 : 0.0;
 
    initialized_.store(true);
    return ok();
}

References kcenon::network::error_codes::common_errors::already_exists, backend_type_, cached_metrics_, config, kcenon::network::integration::BridgeMetrics::custom_metrics, kcenon::network::error_void(), initialized_, kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::integration::BridgeMetrics::is_healthy, kcenon::network::integration::BridgeMetrics::last_activity, logger_, metrics_mutex_, monitor_, monitoring_enabled_, and kcenon::network::ok().

Here is the call graph for this function:

◆ is_initialized()

bool kcenon::network::integration::ObservabilityBridge::is_initialized ( ) const

overridevirtual

Check if the bridge is initialized.

Returns: true if initialized and ready, false otherwise

Implements kcenon::network::integration::INetworkBridge.

Definition at line 105 of file observability_bridge.cpp.

                                               {
    return initialized_.load() && logger_ && monitor_;
}

References initialized_, logger_, and monitor_.

◆ shutdown()

VoidResult kcenon::network::integration::ObservabilityBridge::shutdown ( )

overridevirtual

Shutdown the bridge.

Returns: ok() on success, error_info on failure

Shuts down the bridge and flushes any buffered logs. Logger and monitor lifecycle is managed externally.

This method is idempotent - multiple calls are safe.

Implements kcenon::network::integration::INetworkBridge.

Definition at line 80 of file observability_bridge.cpp.

                                         {
    if (!initialized_.load()) {
        return ok(); // Idempotent: already shut down
    }
 
    // Flush logger before shutdown
    if (logger_) {
        try {
            logger_->flush();
        } catch (...) {
            // Ignore flush errors during shutdown
        }
    }
 
    // Update metrics to reflect shutdown state
    {
        std::lock_guard<std::mutex> lock(metrics_mutex_);
        cached_metrics_.is_healthy = false;
        cached_metrics_.last_activity = std::chrono::steady_clock::now();
    }
 
    initialized_.store(false);
    return ok();
}