global_logger_registry.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 "logger_interface.h"
#include "registry_audit_log.h"
 
#include <atomic>
#include <functional>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <string>
#include <unordered_map>
 
namespace kcenon::common {
namespace interfaces {
 
class NullLogger : public ILogger {
public:
    NullLogger() = default;
    ~NullLogger() override = default;
 
    VoidResult log(log_level /*level*/, const std::string& /*message*/) override {
        return VoidResult::ok({});
    }
 
    VoidResult log(log_level /*level*/,
                   std::string_view /*message*/,
                   const source_location& /*loc*/ = source_location::current()) override {
        return VoidResult::ok({});
    }
 
    VoidResult log(const log_entry& /*entry*/) override {
        return VoidResult::ok({});
    }
 
    bool is_enabled(log_level /*level*/) const override {
        return false;
    }
 
    VoidResult set_level(log_level /*level*/) override {
        return VoidResult::ok({});
    }
 
    log_level get_level() const override {
        return log_level::off;
    }
 
    VoidResult flush() override {
        return VoidResult::ok({});
    }
};
 
class GlobalLoggerRegistry : public ILoggerRegistry {
public:
    static GlobalLoggerRegistry& instance();
 
    // Delete copy and move operations
    GlobalLoggerRegistry(const GlobalLoggerRegistry&) = delete;
    GlobalLoggerRegistry& operator=(const GlobalLoggerRegistry&) = delete;
    GlobalLoggerRegistry(GlobalLoggerRegistry&&) = delete;
    GlobalLoggerRegistry& operator=(GlobalLoggerRegistry&&) = delete;
 
    // ===== ILoggerRegistry Implementation =====
 
    VoidResult register_logger(const std::string& name,
                               std::shared_ptr<ILogger> logger) override;
 
    std::shared_ptr<ILogger> get_logger(const std::string& name) override;
 
    VoidResult unregister_logger(const std::string& name) override;
 
    std::shared_ptr<ILogger> get_default_logger() override;
 
    VoidResult set_default_logger(std::shared_ptr<ILogger> logger) override;
 
    // ===== Extended API for Factory Support =====
 
    VoidResult register_factory(const std::string& name, LoggerFactory factory);
 
    VoidResult set_default_factory(LoggerFactory factory);
 
    bool has_logger(const std::string& name) const;
 
    bool has_default_logger() const;
 
    void clear();
 
    size_t size() const;
 
    // ===== Security Controls =====
 
    void freeze();
 
    bool is_frozen() const;
 
    static std::shared_ptr<ILogger> null_logger();
 
private:
    GlobalLoggerRegistry() = default;
    ~GlobalLoggerRegistry() = default;
 
    std::shared_ptr<ILogger> create_from_factory(const std::string& name);
 
    std::shared_ptr<ILogger> create_default_from_factory();
 
    mutable std::shared_mutex mutex_;
    std::unordered_map<std::string, std::shared_ptr<ILogger>> loggers_;
    std::unordered_map<std::string, LoggerFactory> factories_;
    std::shared_ptr<ILogger> default_logger_;
    LoggerFactory default_factory_;
    std::atomic<bool> frozen_{false};
};
 
// ============================================================================
// GlobalLoggerRegistry Implementation
// ============================================================================
 
inline GlobalLoggerRegistry& GlobalLoggerRegistry::instance() {
    // Intentionally leak to avoid static destruction order issues.
    // Registry may be accessed during other singletons' destruction.
    static GlobalLoggerRegistry* instance = new GlobalLoggerRegistry();
    return *instance;
}
 
inline std::shared_ptr<ILogger> GlobalLoggerRegistry::null_logger() {
    // Intentionally leak to avoid static destruction order issues.
    // NullLogger may be accessed during other singletons' destruction.
    static auto* null_logger_ptr =
        new std::shared_ptr<NullLogger>(std::make_shared<NullLogger>());
    return *null_logger_ptr;
}
 
inline VoidResult GlobalLoggerRegistry::register_logger(
    const std::string& name,
    std::shared_ptr<ILogger> logger) {
 
    if (is_frozen()) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::register_logger, name,
            interfaces::source_location::current(), false,
            "Registry is frozen"));
        return make_error<std::monostate>(
            error_codes::REGISTRY_FROZEN,
            "Cannot register logger: registry is frozen",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    if (name.empty()) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::register_logger, name,
            interfaces::source_location::current(), false,
            "Logger name cannot be empty"));
        return make_error<std::monostate>(
            error_codes::INVALID_ARGUMENT,
            "Logger name cannot be empty",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    if (!logger) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::register_logger, name,
            interfaces::source_location::current(), false,
            "Logger instance cannot be null"));
        return make_error<std::monostate>(
            error_codes::INVALID_ARGUMENT,
            "Logger instance cannot be null",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    std::unique_lock lock(mutex_);
    loggers_[name] = std::move(logger);
    // Remove factory if one exists for this name (logger takes precedence)
    factories_.erase(name);
 
    RegistryAuditLog::log_event(registry_event(
        registry_action::register_logger, name,
        interfaces::source_location::current(), true));
 
    return VoidResult::ok({});
}
 
inline std::shared_ptr<ILogger> GlobalLoggerRegistry::get_logger(const std::string& name) {
    // First, try to get existing logger with read lock
    {
        std::shared_lock lock(mutex_);
        auto it = loggers_.find(name);
        if (it != loggers_.end()) {
            return it->second;
        }
    }
 
    // Try to create from factory
    auto logger = create_from_factory(name);
    if (logger) {
        return logger;
    }
 
    // Return NullLogger as fallback
    return null_logger();
}
 
inline VoidResult GlobalLoggerRegistry::unregister_logger(const std::string& name) {
    if (is_frozen()) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::unregister_logger, name,
            interfaces::source_location::current(), false,
            "Registry is frozen"));
        return make_error<std::monostate>(
            error_codes::REGISTRY_FROZEN,
            "Cannot unregister logger: registry is frozen",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    std::unique_lock lock(mutex_);
    loggers_.erase(name);
    factories_.erase(name);
 
    RegistryAuditLog::log_event(registry_event(
        registry_action::unregister_logger, name,
        interfaces::source_location::current(), true));
 
    return VoidResult::ok({});
}
 
inline std::shared_ptr<ILogger> GlobalLoggerRegistry::get_default_logger() {
    // First, try to get existing default logger with read lock
    {
        std::shared_lock lock(mutex_);
        if (default_logger_) {
            return default_logger_;
        }
    }
 
    // Try to create from factory
    auto logger = create_default_from_factory();
    if (logger) {
        return logger;
    }
 
    // Return NullLogger as fallback
    return null_logger();
}
 
inline VoidResult GlobalLoggerRegistry::set_default_logger(std::shared_ptr<ILogger> logger) {
    if (is_frozen()) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::set_default_logger, "default",
            interfaces::source_location::current(), false,
            "Registry is frozen"));
        return make_error<std::monostate>(
            error_codes::REGISTRY_FROZEN,
            "Cannot set default logger: registry is frozen",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    if (!logger) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::set_default_logger, "default",
            interfaces::source_location::current(), false,
            "Default logger instance cannot be null"));
        return make_error<std::monostate>(
            error_codes::INVALID_ARGUMENT,
            "Default logger instance cannot be null",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    std::unique_lock lock(mutex_);
    default_logger_ = std::move(logger);
    // Clear factory since we have a concrete instance
    default_factory_ = nullptr;
 
    RegistryAuditLog::log_event(registry_event(
        registry_action::set_default_logger, "default",
        interfaces::source_location::current(), true));
 
    return VoidResult::ok({});
}
 
inline VoidResult GlobalLoggerRegistry::register_factory(
    const std::string& name,
    LoggerFactory factory) {
 
    if (is_frozen()) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::register_factory, name,
            interfaces::source_location::current(), false,
            "Registry is frozen"));
        return make_error<std::monostate>(
            error_codes::REGISTRY_FROZEN,
            "Cannot register factory: registry is frozen",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    if (name.empty()) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::register_factory, name,
            interfaces::source_location::current(), false,
            "Logger name cannot be empty"));
        return make_error<std::monostate>(
            error_codes::INVALID_ARGUMENT,
            "Logger name cannot be empty",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    if (!factory) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::register_factory, name,
            interfaces::source_location::current(), false,
            "Factory function cannot be null"));
        return make_error<std::monostate>(
            error_codes::INVALID_ARGUMENT,
            "Factory function cannot be null",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    std::unique_lock lock(mutex_);
 
    // Only register factory if no logger already exists
    if (loggers_.find(name) != loggers_.end()) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::register_factory, name,
            interfaces::source_location::current(), false,
            "Logger already registered with name: " + name));
        return make_error<std::monostate>(
            error_codes::ALREADY_EXISTS,
            "Logger already registered with name: " + name,
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    factories_[name] = std::move(factory);
 
    RegistryAuditLog::log_event(registry_event(
        registry_action::register_factory, name,
        interfaces::source_location::current(), true));
 
    return VoidResult::ok({});
}
 
inline VoidResult GlobalLoggerRegistry::set_default_factory(LoggerFactory factory) {
    if (is_frozen()) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::set_default_factory, "default",
            interfaces::source_location::current(), false,
            "Registry is frozen"));
        return make_error<std::monostate>(
            error_codes::REGISTRY_FROZEN,
            "Cannot set default factory: registry is frozen",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    if (!factory) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::set_default_factory, "default",
            interfaces::source_location::current(), false,
            "Factory function cannot be null"));
        return make_error<std::monostate>(
            error_codes::INVALID_ARGUMENT,
            "Factory function cannot be null",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    std::unique_lock lock(mutex_);
 
    // Only set factory if no default logger exists
    if (default_logger_) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::set_default_factory, "default",
            interfaces::source_location::current(), false,
            "Default logger already registered"));
        return make_error<std::monostate>(
            error_codes::ALREADY_EXISTS,
            "Default logger already registered",
            "interfaces::GlobalLoggerRegistry"
        );
    }
 
    default_factory_ = std::move(factory);
 
    RegistryAuditLog::log_event(registry_event(
        registry_action::set_default_factory, "default",
        interfaces::source_location::current(), true));
 
    return VoidResult::ok({});
}
 
inline bool GlobalLoggerRegistry::has_logger(const std::string& name) const {
    std::shared_lock lock(mutex_);
    return loggers_.find(name) != loggers_.end() ||
           factories_.find(name) != factories_.end();
}
 
inline bool GlobalLoggerRegistry::has_default_logger() const {
    std::shared_lock lock(mutex_);
    return default_logger_ != nullptr || default_factory_ != nullptr;
}
 
inline void GlobalLoggerRegistry::clear() {
    if (is_frozen()) {
        RegistryAuditLog::log_event(registry_event(
            registry_action::clear_loggers, "",
            interfaces::source_location::current(), false,
            "Registry is frozen"));
        // Silently ignore clear when frozen to maintain API compatibility
        return;
    }
 
    std::unique_lock lock(mutex_);
    loggers_.clear();
    factories_.clear();
    default_logger_.reset();
    default_factory_ = nullptr;
 
    RegistryAuditLog::log_event(registry_event(
        registry_action::clear_loggers, "",
        interfaces::source_location::current(), true));
}
 
inline size_t GlobalLoggerRegistry::size() const {
    std::shared_lock lock(mutex_);
    return loggers_.size() + factories_.size();
}
 
inline void GlobalLoggerRegistry::freeze() {
    frozen_.store(true, std::memory_order_release);
 
    RegistryAuditLog::log_event(registry_event(
        registry_action::freeze_logger_registry, "",
        interfaces::source_location::current(), true));
}
 
inline bool GlobalLoggerRegistry::is_frozen() const {
    return frozen_.load(std::memory_order_acquire);
}
 
inline std::shared_ptr<ILogger> GlobalLoggerRegistry::create_from_factory(
    const std::string& name) {
 
    std::unique_lock lock(mutex_);
 
    // Check again under write lock
    auto logger_it = loggers_.find(name);
    if (logger_it != loggers_.end()) {
        return logger_it->second;
    }
 
    auto factory_it = factories_.find(name);
    if (factory_it == factories_.end()) {
        return nullptr;
    }
 
    // Create logger from factory
    auto logger = factory_it->second();
    if (logger) {
        loggers_[name] = logger;
        factories_.erase(factory_it);
    }
 
    return logger;
}
 
inline std::shared_ptr<ILogger> GlobalLoggerRegistry::create_default_from_factory() {
    std::unique_lock lock(mutex_);
 
    // Check again under write lock
    if (default_logger_) {
        return default_logger_;
    }
 
    if (!default_factory_) {
        return nullptr;
    }
 
    // Create logger from factory
    auto logger = default_factory_();
    if (logger) {
        default_logger_ = logger;
        default_factory_ = nullptr;
    }
 
    return logger;
}
 
// ============================================================================
// Convenience Functions
// ============================================================================
 
inline GlobalLoggerRegistry& get_registry() {
    return GlobalLoggerRegistry::instance();
}
 
inline std::shared_ptr<ILogger> get_logger() {
    return GlobalLoggerRegistry::instance().get_default_logger();
}
 
inline std::shared_ptr<ILogger> get_logger(const std::string& name) {
    return GlobalLoggerRegistry::instance().get_logger(name);
}
 
} // namespace interfaces
} // namespace kcenon::common