Thread-safe singleton registry for managing logger instances. More...

#include <global_logger_registry.h>

Inheritance diagram for kcenon::common::interfaces::GlobalLoggerRegistry:

Collaboration diagram for kcenon::common::interfaces::GlobalLoggerRegistry:

Public Member Functions
	GlobalLoggerRegistry (const GlobalLoggerRegistry &)=delete

GlobalLoggerRegistry &	operator= (const GlobalLoggerRegistry &)=delete

	GlobalLoggerRegistry (GlobalLoggerRegistry &&)=delete

GlobalLoggerRegistry &	operator= (GlobalLoggerRegistry &&)=delete

VoidResult	register_logger (const std::string &name, std::shared_ptr< ILogger > logger) override
	Register a logger with a name.

std::shared_ptr< ILogger >	get_logger (const std::string &name) override
	Get a logger by name.

VoidResult	unregister_logger (const std::string &name) override
	Remove a logger by name.

std::shared_ptr< ILogger >	get_default_logger () override
	Get the default logger.

VoidResult	set_default_logger (std::shared_ptr< ILogger > logger) override
	Set the default logger.

VoidResult	register_factory (const std::string &name, LoggerFactory factory)
	Register a factory for lazy logger creation.

VoidResult	set_default_factory (LoggerFactory factory)
	Set a factory for the default logger.

bool	has_logger (const std::string &name) const
	Check if a logger is registered.

bool	has_default_logger () const
	Check if a default logger is available.

void	clear ()
	Clear all registered loggers and factories.

size_t	size () const
	Get the number of registered loggers.

void	freeze ()
	Freeze the registry to prevent further modifications.

bool	is_frozen () const
	Check if the registry is frozen.

Public Member Functions inherited from kcenon::common::interfaces::ILoggerRegistry
virtual	~ILoggerRegistry ()=default

virtual	~ILoggerRegistry ()=default

Static Public Member Functions
static GlobalLoggerRegistry &	instance ()
	Get the singleton instance of GlobalLoggerRegistry.

static std::shared_ptr< ILogger >	null_logger ()
	Get the shared NullLogger instance.

Private Member Functions
	GlobalLoggerRegistry ()=default

	~GlobalLoggerRegistry ()=default

std::shared_ptr< ILogger >	create_from_factory (const std::string &name)
	Create logger from factory if available.

std::shared_ptr< ILogger >	create_default_from_factory ()
	Create default logger from factory if available.

Private Attributes
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}

Detailed Description

Thread-safe singleton registry for managing logger instances.

GlobalLoggerRegistry implements the ILoggerRegistry interface and provides:

Thread-safe registration and retrieval of named loggers
Default logger management
Factory-based lazy initialization for deferred logger creation
NullLogger fallback for unregistered logger requests

This class resolves the circular dependency between thread_system and logger_system by providing a centralized, decoupled logging registry that can be accessed from any subsystem without creating direct dependencies.

Usage Example:

// Get the global registry
auto& registry = GlobalLoggerRegistry::instance();
 
// Register a default logger
auto logger = std::make_shared<MyLogger>();
registry.set_default_logger(logger);
 
// Register a named logger
registry.register_logger("network", network_logger);
 
// Retrieve loggers
auto default_log = registry.get_default_logger();
auto network_log = registry.get_logger("network");
 
// Use factory for lazy initialization
registry.register_factory("database", []() {
    return std::make_shared<DatabaseLogger>();
});

Definition at line 128 of file global_logger_registry.h.

Constructor & Destructor Documentation

◆ GlobalLoggerRegistry() [1/3]

kcenon::common::interfaces::GlobalLoggerRegistry::GlobalLoggerRegistry ( const GlobalLoggerRegistry & )

delete

◆ GlobalLoggerRegistry() [2/3]

kcenon::common::interfaces::GlobalLoggerRegistry::GlobalLoggerRegistry ( GlobalLoggerRegistry && )

delete

◆ GlobalLoggerRegistry() [3/3]

kcenon::common::interfaces::GlobalLoggerRegistry::GlobalLoggerRegistry ( )

privatedefault

Referenced by instance().

Here is the caller graph for this function:

◆ ~GlobalLoggerRegistry()

kcenon::common::interfaces::GlobalLoggerRegistry::~GlobalLoggerRegistry ( )

privatedefault

Member Function Documentation

◆ clear()

void kcenon::common::interfaces::GlobalLoggerRegistry::clear ( )

inline

Clear all registered loggers and factories.

Removes all registered loggers, factories, and the default logger. Useful for testing or application shutdown.

Definition at line 643 of file global_logger_registry.h.

                                        {
    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));
}

References kcenon::common::interfaces::clear_loggers, kcenon::common::source_location::current(), default_factory_, default_logger_, factories_, is_frozen(), kcenon::common::interfaces::RegistryAuditLog::log_event(), loggers_, and mutex_.

Referenced by kcenon::common::bootstrap::SystemBootstrapper::clear_loggers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_default_from_factory()

std::shared_ptr< ILogger > kcenon::common::interfaces::GlobalLoggerRegistry::create_default_from_factory ( )

inlineprivate

Create default logger from factory if available.

Returns: Logger instance or nullptr if no factory

Definition at line 707 of file global_logger_registry.h.

                                                                                {
    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;
}

References default_factory_, default_logger_, and mutex_.

Referenced by get_default_logger().

Here is the caller graph for this function:

◆ create_from_factory()

std::shared_ptr< ILogger > kcenon::common::interfaces::GlobalLoggerRegistry::create_from_factory ( const std::string & name )

inlineprivate

Create logger from factory if available.

Internal helper that creates a logger using a registered factory and stores it in the logger map.

Parameters

name	Logger name
lock	Reference to held read lock (will be upgraded if needed)

Returns: Logger instance or nullptr if no factory

Definition at line 681 of file global_logger_registry.h.

                           {
 
    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;
}

References factories_, loggers_, and mutex_.

Referenced by get_logger().

Here is the caller graph for this function:

◆ freeze()

void kcenon::common::interfaces::GlobalLoggerRegistry::freeze ( )

inline

Freeze the registry to prevent further modifications.

Once frozen, the registry cannot be modified (no registrations, unregistrations, or clears allowed). This is a one-way operation and cannot be undone.

Note: This should be called after system initialization to prevent unauthorized logger swapping which could be used to suppress security audit logs.; This is a security feature to prevent audit log tampering.

See also: Issue #206 for security requirements.

Definition at line 669 of file global_logger_registry.h.

                                         {
    frozen_.store(true, std::memory_order_release);
 
    RegistryAuditLog::log_event(registry_event(
        registry_action::freeze_logger_registry, "",
        interfaces::source_location::current(), true));
}

References kcenon::common::source_location::current(), kcenon::common::interfaces::freeze_logger_registry, frozen_, and kcenon::common::interfaces::RegistryAuditLog::log_event().

Referenced by kcenon::common::bootstrap::SystemBootstrapper::initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_default_logger()

std::shared_ptr< ILogger > kcenon::common::interfaces::GlobalLoggerRegistry::get_default_logger ( )

inlineoverridevirtual

Get the default logger.

Returns the default logger instance. If no default logger is set, returns a NullLogger instance.

Returns: Default logger instance or NullLogger

Implements kcenon::common::interfaces::ILoggerRegistry.

Definition at line 463 of file global_logger_registry.h.

                                                                       {
    // 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();
}

References create_default_from_factory(), default_logger_, mutex_, and null_logger().

Referenced by kcenon::common::interfaces::get_logger().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_logger()

std::shared_ptr< ILogger > kcenon::common::interfaces::GlobalLoggerRegistry::get_logger ( const std::string & name )

inlineoverridevirtual

Get a logger by name.

Retrieves a logger registered under the specified name. If no logger is registered with that name but a factory exists, the factory will be invoked to create the logger (lazy initialization).

If no logger or factory is registered, returns a NullLogger instance.

Parameters

name	Logger name (case-sensitive)

Returns: Logger instance or NullLogger if not found

Implements kcenon::common::interfaces::ILoggerRegistry.

Definition at line 419 of file global_logger_registry.h.

                                                                                    {
    // 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();
}

References create_from_factory(), loggers_, mutex_, and null_logger().

Referenced by kcenon::common::interfaces::get_logger().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_default_logger()

bool kcenon::common::interfaces::GlobalLoggerRegistry::has_default_logger ( ) const

inline

Check if a default logger is available.

Checks if a default logger or factory is registered.

Returns: true if a default logger or factory is available

Definition at line 638 of file global_logger_registry.h.

                                                           {
    std::shared_lock lock(mutex_);
    return default_logger_ != nullptr || default_factory_ != nullptr;
}

References default_factory_, default_logger_, and mutex_.

◆ has_logger()

bool kcenon::common::interfaces::GlobalLoggerRegistry::has_logger ( const std::string & name ) const

inline

Check if a logger is registered.

Checks if a logger or factory is registered under the specified name.

Parameters

name	Logger name to check

Returns: true if a logger or factory is registered

Definition at line 632 of file global_logger_registry.h.

                                                                        {
    std::shared_lock lock(mutex_);
    return loggers_.find(name) != loggers_.end() ||
           factories_.find(name) != factories_.end();
}

References factories_, loggers_, and mutex_.

◆ instance()

GlobalLoggerRegistry & kcenon::common::interfaces::GlobalLoggerRegistry::instance ( )

inlinestatic

Get the singleton instance of GlobalLoggerRegistry.

Returns a reference to the application-wide singleton registry. Thread-safe for concurrent access.

Note: Uses Intentional Leak pattern to avoid Static Destruction Order Fiasco (SDOF). The registry may be accessed during other static objects' destruction, so it must remain valid throughout the entire process lifetime. The leaked memory is reclaimed by the OS at process termination.

Returns: Reference to the GlobalLoggerRegistry singleton

Definition at line 352 of file global_logger_registry.h.

                                                            {
    // Intentionally leak to avoid static destruction order issues.
    // Registry may be accessed during other singletons' destruction.
    static GlobalLoggerRegistry* instance = new GlobalLoggerRegistry();
    return *instance;
}

References GlobalLoggerRegistry(), and instance().

Referenced by kcenon::common::bootstrap::SystemBootstrapper::clear_loggers(), kcenon::common::interfaces::get_logger(), kcenon::common::interfaces::get_logger(), kcenon::common::interfaces::get_registry(), kcenon::common::bootstrap::SystemBootstrapper::initialize(), instance(), and kcenon::common::bootstrap::SystemBootstrapper::register_loggers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_frozen()

bool kcenon::common::interfaces::GlobalLoggerRegistry::is_frozen ( ) const

inline

Check if the registry is frozen.

Returns: true if the registry is frozen and cannot be modified

Definition at line 677 of file global_logger_registry.h.

                                                  {
    return frozen_.load(std::memory_order_acquire);
}

References frozen_.

Referenced by clear(), register_factory(), register_logger(), set_default_factory(), set_default_logger(), and unregister_logger().

Here is the caller graph for this function:

◆ null_logger()

std::shared_ptr< ILogger > kcenon::common::interfaces::GlobalLoggerRegistry::null_logger ( )

inlinestatic

Get the shared NullLogger instance.

Returns the singleton NullLogger instance used as a fallback when no logger is registered.

Note: Uses Intentional Leak pattern to avoid Static Destruction Order Fiasco (SDOF). The NullLogger may be accessed during other static objects' destruction, so it must remain valid throughout the entire process lifetime.

Returns: Shared pointer to NullLogger

Definition at line 359 of file global_logger_registry.h.

                                                                {
    // 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;
}

Referenced by get_default_logger(), and get_logger().

Here is the caller graph for this function:

◆ operator=() [1/2]

GlobalLoggerRegistry & kcenon::common::interfaces::GlobalLoggerRegistry::operator= ( const GlobalLoggerRegistry & )

delete

◆ operator=() [2/2]

GlobalLoggerRegistry & kcenon::common::interfaces::GlobalLoggerRegistry::operator= ( GlobalLoggerRegistry && )

delete

◆ register_factory()

VoidResult kcenon::common::interfaces::GlobalLoggerRegistry::register_factory	(	const std::string &	name,
		LoggerFactory	factory )

inline

Register a factory for lazy logger creation.

Registers a factory function that will be invoked when a logger with the specified name is first requested. This enables deferred initialization of loggers.

Parameters

name	Logger name (case-sensitive)
factory	Factory function that creates the logger

Returns: VoidResult indicating success or error

Definition at line 519 of file global_logger_registry.h.

                           {
 
    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({});
}

References kcenon::common::error_codes::ALREADY_EXISTS, kcenon::common::source_location::current(), factories_, kcenon::common::error_codes::INVALID_ARGUMENT, is_frozen(), kcenon::common::interfaces::RegistryAuditLog::log_event(), loggers_, kcenon::common::make_error(), mutex_, kcenon::common::Result< T >::ok(), kcenon::common::interfaces::register_factory, and kcenon::common::error_codes::REGISTRY_FROZEN.

Here is the call graph for this function:

◆ register_logger()

VoidResult kcenon::common::interfaces::GlobalLoggerRegistry::register_logger	(	const std::string &	name,
		std::shared_ptr< ILogger >	logger )

inlineoverridevirtual

Register a logger with a name.

Registers a logger instance under the specified name. If a logger with the same name already exists, it will be replaced.

Parameters

name	Logger name (case-sensitive)
logger	Logger instance to register

Returns: VoidResult indicating success or error

Implements kcenon::common::interfaces::ILoggerRegistry.

Definition at line 367 of file global_logger_registry.h.

                                   {
 
    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({});
}

References kcenon::common::source_location::current(), factories_, kcenon::common::error_codes::INVALID_ARGUMENT, is_frozen(), kcenon::common::interfaces::RegistryAuditLog::log_event(), loggers_, kcenon::common::make_error(), mutex_, kcenon::common::Result< T >::ok(), kcenon::common::interfaces::register_logger, and kcenon::common::error_codes::REGISTRY_FROZEN.

Here is the call graph for this function:

◆ set_default_factory()

VoidResult kcenon::common::interfaces::GlobalLoggerRegistry::set_default_factory ( LoggerFactory factory )

inline

Set a factory for the default logger.

Registers a factory function for creating the default logger. The factory will be invoked when get_default_logger() is called and no default logger has been set.

Parameters

factory Factory function that creates the default logger

Returns: VoidResult indicating success or error

Definition at line 583 of file global_logger_registry.h.

                                                                                 {
    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({});
}

References kcenon::common::error_codes::ALREADY_EXISTS, kcenon::common::source_location::current(), default_factory_, default_logger_, kcenon::common::error_codes::INVALID_ARGUMENT, is_frozen(), kcenon::common::interfaces::RegistryAuditLog::log_event(), kcenon::common::make_error(), mutex_, kcenon::common::Result< T >::ok(), kcenon::common::error_codes::REGISTRY_FROZEN, and kcenon::common::interfaces::set_default_factory.

Here is the call graph for this function:

◆ set_default_logger()

VoidResult kcenon::common::interfaces::GlobalLoggerRegistry::set_default_logger ( std::shared_ptr< ILogger > logger )

inlineoverridevirtual

Set the default logger.

Sets the default logger instance. The default logger is used when no specific logger name is provided.

Parameters

logger Logger instance to set as default

Returns: VoidResult indicating success or error

Implements kcenon::common::interfaces::ILoggerRegistry.

Definition at line 482 of file global_logger_registry.h.

                                                                                        {
    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({});
}

References kcenon::common::source_location::current(), default_factory_, default_logger_, kcenon::common::error_codes::INVALID_ARGUMENT, is_frozen(), kcenon::common::interfaces::RegistryAuditLog::log_event(), kcenon::common::make_error(), mutex_, kcenon::common::Result< T >::ok(), kcenon::common::error_codes::REGISTRY_FROZEN, and kcenon::common::interfaces::set_default_logger.

Here is the call graph for this function:

◆ size()

size_t kcenon::common::interfaces::GlobalLoggerRegistry::size ( ) const

inline

Get the number of registered loggers.

Returns the count of registered named loggers (not including the default logger).

Returns: Number of registered loggers

Definition at line 664 of file global_logger_registry.h.

                                               {
    std::shared_lock lock(mutex_);
    return loggers_.size() + factories_.size();
}

References factories_, loggers_, and mutex_.

◆ unregister_logger()

VoidResult kcenon::common::interfaces::GlobalLoggerRegistry::unregister_logger ( const std::string & name )

inlineoverridevirtual

Remove a logger by name.

Unregisters a logger from the registry. Also removes any associated factory if present.

Parameters

name	Logger name

Returns: VoidResult indicating success (success even if not found)

Implements kcenon::common::interfaces::ILoggerRegistry.

Definition at line 439 of file global_logger_registry.h.

                                                                               {
    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({});
}

References kcenon::common::source_location::current(), factories_, is_frozen(), kcenon::common::interfaces::RegistryAuditLog::log_event(), loggers_, kcenon::common::make_error(), mutex_, kcenon::common::Result< T >::ok(), kcenon::common::error_codes::REGISTRY_FROZEN, and kcenon::common::interfaces::unregister_logger.

Here is the call graph for this function:

Member Data Documentation

◆ default_factory_

LoggerFactory kcenon::common::interfaces::GlobalLoggerRegistry::default_factory_

private

Definition at line 344 of file global_logger_registry.h.

Referenced by clear(), create_default_from_factory(), has_default_logger(), set_default_factory(), and set_default_logger().

◆ default_logger_

std::shared_ptr<ILogger> kcenon::common::interfaces::GlobalLoggerRegistry::default_logger_

private

Definition at line 343 of file global_logger_registry.h.

Referenced by clear(), create_default_from_factory(), get_default_logger(), has_default_logger(), set_default_factory(), and set_default_logger().

◆ factories_

std::unordered_map<std::string, LoggerFactory> kcenon::common::interfaces::GlobalLoggerRegistry::factories_

private

Definition at line 342 of file global_logger_registry.h.

Referenced by clear(), create_from_factory(), has_logger(), register_factory(), register_logger(), size(), and unregister_logger().

◆ frozen_

std::atomic<bool> kcenon::common::interfaces::GlobalLoggerRegistry::frozen_ {false}

private

Definition at line 345 of file global_logger_registry.h.

345{false};

Referenced by freeze(), and is_frozen().

◆ loggers_

std::unordered_map<std::string, std::shared_ptr<ILogger> > kcenon::common::interfaces::GlobalLoggerRegistry::loggers_

private

Definition at line 341 of file global_logger_registry.h.

Referenced by clear(), create_from_factory(), get_logger(), has_logger(), register_factory(), register_logger(), size(), and unregister_logger().

◆ mutex_

std::shared_mutex kcenon::common::interfaces::GlobalLoggerRegistry::mutex_

mutableprivate

Definition at line 340 of file global_logger_registry.h.

Referenced by clear(), create_default_from_factory(), create_from_factory(), get_default_logger(), get_logger(), has_default_logger(), has_logger(), register_factory(), register_logger(), set_default_factory(), set_default_logger(), size(), and unregister_logger().

The documentation for this class was generated from the following file:

include/kcenon/common/interfaces/global_logger_registry.h

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ GlobalLoggerRegistry() [1/3]

◆ GlobalLoggerRegistry() [2/3]

◆ GlobalLoggerRegistry() [3/3]

◆ ~GlobalLoggerRegistry()

Member Function Documentation

◆ clear()

◆ create_default_from_factory()

◆ create_from_factory()

◆ freeze()

◆ get_default_logger()

◆ get_logger()

◆ has_default_logger()

◆ has_logger()

◆ instance()

◆ is_frozen()

◆ null_logger()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ register_factory()

◆ register_logger()

◆ set_default_factory()

◆ set_default_logger()

◆ size()

◆ unregister_logger()

Member Data Documentation

◆ default_factory_

◆ default_logger_

◆ factories_

◆ frozen_

◆ loggers_

◆ mutex_