service_registration.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 <memory>
#include "../config/feature_flags.h"
 
#if KCENON_HAS_COMMON_SYSTEM
 
#include <kcenon/common/di/service_container.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
 
#include "../core/performance_monitor.h"
#include "../adapters/performance_monitor_adapter.h"
 
namespace kcenon::monitoring::di {
 
struct monitor_registration_config {
    std::string monitor_name = "default_performance_monitor";
 
    double cpu_threshold = 80.0;
 
    double memory_threshold = 90.0;
 
    std::chrono::milliseconds latency_threshold{1000};
 
    bool enable_system_monitoring = true;
 
    bool enable_lock_free = false;
 
    common::di::service_lifetime lifetime = common::di::service_lifetime::singleton;
};
 
inline common::VoidResult register_monitor_services(
    common::di::IServiceContainer& container,
    const monitor_registration_config& config = {}) {
 
    // Check if already registered
    if (container.is_registered<common::interfaces::IMonitor>()) {
        return common::make_error<std::monostate>(
            common::di::di_error_codes::already_registered,
            "IMonitor is already registered",
            "monitoring_system::di"
        );
    }
 
    // Register monitor factory
    return container.register_factory<common::interfaces::IMonitor>(
        [config](common::di::IServiceContainer&) -> std::shared_ptr<common::interfaces::IMonitor> {
            // Create performance_monitor with configuration
            auto monitor = std::make_shared<performance_monitor>(config.monitor_name);
 
            // Apply thresholds
            monitor->set_cpu_threshold(config.cpu_threshold);
            monitor->set_memory_threshold(config.memory_threshold);
            monitor->set_latency_threshold(config.latency_threshold);
 
            // Configure lock-free mode if requested
            monitor->get_profiler().set_lock_free_mode(config.enable_lock_free);
 
            // Initialize system monitoring if enabled
            if (config.enable_system_monitoring) {
                auto init_result = monitor->initialize();
                if (init_result.is_err()) {
                    // Log warning but continue - system monitoring is optional
                    // In production, consider using a logger here
                }
            }
 
            // Create adapter that implements IMonitor
            return std::make_shared<performance_monitor_adapter>(std::move(monitor));
        },
        config.lifetime
    );
}
 
inline common::VoidResult register_monitor_instance(
    common::di::IServiceContainer& container,
    std::shared_ptr<performance_monitor> monitor) {
 
    if (!monitor) {
        return common::make_error<std::monostate>(
            common::error_codes::INVALID_ARGUMENT,
            "Cannot register null monitor instance",
            "monitoring_system::di"
        );
    }
 
    auto adapter = std::make_shared<performance_monitor_adapter>(std::move(monitor));
 
    return container.register_instance<common::interfaces::IMonitor>(adapter);
}
 
inline common::VoidResult unregister_monitor_services(
    common::di::IServiceContainer& container) {
 
    return container.unregister<common::interfaces::IMonitor>();
}
 
inline std::shared_ptr<performance_monitor> get_underlying_performance_monitor(
    const std::shared_ptr<common::interfaces::IMonitor>& monitor) {
 
    auto adapter = std::dynamic_pointer_cast<performance_monitor_adapter>(monitor);
    if (adapter) {
        return adapter->get_wrapped_monitor();
    }
    return nullptr;
}
 
} // namespace kcenon::monitoring::di
 
#endif // KCENON_HAS_COMMON_SYSTEM