Main logger implementation providing high-performance logging facilities. More...

#include <logger.h>

Inheritance diagram for kcenon::logger::logger:

Collaboration diagram for kcenon::logger::logger:

Classes
class	impl

Public Member Functions
	logger (bool async=true, std::size_t buffer_size=8192, std::unique_ptr< backends::integration_backend > backend=nullptr)
	Constructor with optional configuration.

	~logger ()
	Destructor - ensures all logs are flushed.

common::VoidResult	log (common::interfaces::log_level level, const std::string &message) override
	Log a message with specified level (ILogger interface)

common::VoidResult	log (common::interfaces::log_level level, std::string_view message, const common::source_location &loc=common::source_location::current()) override
	Log a message with source location (ILogger interface, C++20)

common::VoidResult	log (const common::interfaces::log_entry &entry) override
	Log a structured entry (ILogger interface)

bool	is_enabled (common::interfaces::log_level level) const override
	Check if logging is enabled for the specified level (ILogger interface)

common::VoidResult	set_level (common::interfaces::log_level level) override
	Set the minimum log level (ILogger interface)

common::interfaces::log_level	get_level () const override
	Get the current minimum log level (ILogger interface)

common::VoidResult	flush () override
	Flush any buffered log messages (ILogger interface)

common::VoidResult	add_writer (log_writer_ptr writer)

common::VoidResult	clear_writers ()
	Remove all writers.

common::VoidResult	start ()

common::VoidResult	stop ()
	Stop the logger.

bool	is_running () const
	Check if logger is running.

common::VoidResult	enable_metrics_collection (bool enable=true)
	Enable or disable metrics collection.

bool	is_metrics_collection_enabled () const
	Check if metrics collection is enabled.

result< metrics::logger_performance_stats >	get_current_metrics () const
	Get current performance metrics.

result< std::unique_ptr< metrics::logger_performance_stats > >	get_metrics_history (std::chrono::seconds duration) const
	Get metrics history for a specific duration.

common::VoidResult	reset_metrics ()
	Reset performance metrics.

logger_metrics_collector *	get_metrics_collector ()
	Get metrics collector for direct access.

common::VoidResult	add_writer (const std::string &name, log_writer_ptr writer)
	Add a writer with a specific name.

bool	remove_writer (const std::string &name)
	Remove a writer by name.

log_writer_interface *	get_writer (const std::string &name)
	Get a writer by name.

void	set_filter (std::unique_ptr< log_filter_interface > filter)

bool	has_filter () const
	Check if a filter is currently set.

log_router &	get_router ()

const log_router &	get_router () const
	Get the log router (const version)

void	set_router (std::unique_ptr< log_router > router)
	Set a new log router.

bool	has_routing () const
	Check if routing is enabled.

structured_log_builder	log_structured (log_level level)

unified_log_context &	context ()

const unified_log_context &	context () const
	Get the unified context for this logger (const version)

void	set_sampler (std::unique_ptr< sampling::log_sampler > sampler)

sampling::log_sampler *	get_sampler ()
	Get the log sampler (if set)

const sampling::log_sampler *	get_sampler () const
	Get the log sampler (const version)

bool	has_sampling () const
	Check if sampling is enabled.

sampling::sampling_stats	get_sampling_stats () const
	Get sampling statistics.

void	reset_sampling_stats ()
	Reset sampling statistics.

int	get_emergency_fd () const override
	Get file descriptor for emergency writing.

const char *	get_emergency_buffer () const override
	Get emergency buffer pointer.

size_t	get_emergency_buffer_size () const override
	Get emergency buffer size.

Public Member Functions inherited from kcenon::logger::security::critical_logger_interface
virtual	~critical_logger_interface ()=default

Private Attributes
std::unique_ptr< impl >	pimpl_

Detailed Description

Main logger implementation providing high-performance logging facilities.

The logger class provides a high-performance, thread-safe logging system with:

Asynchronous logging with configurable batching for optimal throughput
Multiple writer support for outputting to different destinations simultaneously
Real-time metrics collection and performance monitoring
Configurable filtering and routing of log messages
Integration with monitoring backends for production observability

The logger uses the PIMPL idiom to hide implementation details and maintain ABI stability. Implements common::interfaces::ILogger for standardized logging interface (Phase 2) and common::interfaces::IMonitorable for observability (Phase 2.2). Can be adapted to legacy thread_system interfaces through dedicated adapter classes.

Warning: When using asynchronous mode, ensure proper shutdown by calling stop() and flush() before destroying the logger to prevent loss of buffered messages.

Since: 1.0.0; 2.0.0 Implements common::interfaces::ILogger

Note: For integration with common_system monitoring interfaces, use logger_monitoring_adapter

Definition at line 156 of file logger.h.

Constructor & Destructor Documentation

◆ logger()

kcenon::logger::logger::logger	(	bool	async = true,
		std::size_t	buffer_size = 8192,
		std::unique_ptr< backends::integration_backend >	backend = nullptr )

explicit

Constructor with optional configuration.

Parameters

async	Enable asynchronous logging (default: true)
buffer_size	Size of the log buffer in bytes (default: 8192)
backend	Integration backend for level conversion (default: auto-detect)

Creates a logger instance with the specified configuration. In async mode, a background thread is created to process log messages, providing better performance for high-throughput applications.

If no backend is specified, the logger will auto-detect the appropriate backend based on compile-time flags (USE_THREAD_SYSTEM_INTEGRATION).

Note: The buffer_size parameter affects memory usage and batching efficiency. Larger buffers can improve throughput but increase memory consumption.

Since: 1.0.0

Definition at line 211 of file logger.cpp.

    : pimpl_(std::make_unique<impl>(async, buffer_size, std::move(backend))) {
    // Initialize logger with configuration
}

◆ ~logger()

kcenon::logger::logger::~logger ( )

Destructor - ensures all logs are flushed.

Properly shuts down the logger, ensuring all buffered messages are written to their destinations before destruction. Automatically calls stop() and flush() if the logger is still running.

Warning: Destruction may block until all pending messages are processed.

Since: 1.0.0

Definition at line 216 of file logger.cpp.

                {
    if (pimpl_ && pimpl_->running_) {
        stop();
    }
}

References pimpl_, and stop().

Here is the call graph for this function:

Member Function Documentation

◆ add_writer() [1/2]

common::VoidResult kcenon::logger::logger::add_writer	(	const std::string &	name,
		log_writer_ptr	writer )

Add a writer with a specific name.

Parameters

name	Name for the writer (used for later retrieval/removal)
writer	Unique pointer to the writer

Returns: common::VoidResult Success or error code

Adds a writer with an associated name for later lookup or removal. The writer is also added to the general writers list.

Since: 1.0.0

Definition at line 282 of file logger.cpp.

                                                                                {
    if (!pimpl_) {
        return common::make_error<std::monostate>(
            static_cast<int>(logger_error_code::invalid_configuration),
            "Logger not initialized",
            "logger_system");
    }
    if (!writer) {
        return common::make_error<std::monostate>(
            static_cast<int>(logger_error_code::invalid_argument),
            "Writer cannot be null",
            "logger_system");
    }
 
    std::shared_ptr<log_writer_interface> shared_writer(std::move(writer));
 
    {
        std::lock_guard<std::shared_mutex> lock(pimpl_->writers_mutex_);
        pimpl_->writers_.push_back(shared_writer);
        if (!name.empty()) {
            pimpl_->named_writers_[name] = shared_writer;
        }
    }
 
    // Register with collector if in async mode and running
    if (pimpl_->async_mode_ && pimpl_->collector_ && pimpl_->running_) {
        pimpl_->collector_->add_writer(shared_writer);
    }
 
    return common::ok();
}

References kcenon::logger::invalid_argument, kcenon::logger::invalid_configuration, kcenon::common::ok(), and pimpl_.

Here is the call graph for this function:

◆ add_writer() [2/2]

common::VoidResult kcenon::logger::logger::add_writer ( log_writer_ptr writer )

Examples: critical_logging_example.cpp, decorator_usage.cpp, and writer_builder_example.cpp.

Definition at line 265 of file logger.cpp.

                                                         {
    if (pimpl_ && writer) {
        std::shared_ptr<log_writer_interface> shared_writer(std::move(writer));
 
        {
            std::lock_guard<std::shared_mutex> lock(pimpl_->writers_mutex_);
            pimpl_->writers_.push_back(shared_writer);
        }
 
        // Register with collector if in async mode and running
        if (pimpl_->async_mode_ && pimpl_->collector_ && pimpl_->running_) {
            pimpl_->collector_->add_writer(shared_writer);
        }
    }
    return common::ok();
}

References kcenon::common::ok(), and pimpl_.

Referenced by example_basic_critical_writer(), example_error_handling(), example_hybrid_writer(), example_production_scenarios(), example_production_setup(), and example_write_ahead_logging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_writers()

common::VoidResult kcenon::logger::logger::clear_writers ( )

Remove all writers.

Returns: common::VoidResult Success or error code

Removes all currently registered writers from the logger. After this call, log messages will not be output anywhere until new writers are added.

Warning: This operation cannot be undone. Removed writers are destroyed.

Since: 1.0.0

Definition at line 314 of file logger.cpp.

                                       {
    if (pimpl_) {
        {
            std::lock_guard<std::shared_mutex> lock(pimpl_->writers_mutex_);
            pimpl_->writers_.clear();
            pimpl_->named_writers_.clear();
        }
 
        // Clear collectors writers if in async mode
        if (pimpl_->async_mode_ && pimpl_->collector_) {
            pimpl_->collector_->clear_writers();
        }
    }
    return common::ok();
}

References kcenon::common::ok(), and pimpl_.

Here is the call graph for this function:

◆ context() [1/2]

unified_log_context & kcenon::logger::logger::context ( )

nodiscard

Definition at line 769 of file logger.cpp.

                                     {
    // unified_log_context is thread-safe internally, no external locking needed
    return pimpl_->context_;
}

References pimpl_.

Referenced by kcenon::logger::log_context_scope::log_context_scope(), kcenon::logger::log_context_scope::remove_logger_context(), kcenon::logger::scoped_context_guard::set(), kcenon::logger::scoped_context_guard::set_otel(), kcenon::logger::scoped_context_guard::set_request(), kcenon::logger::scoped_context_guard::set_trace(), and kcenon::logger::scoped_context_guard::~scoped_context_guard().

Here is the caller graph for this function:

◆ context() [2/2]

const unified_log_context & kcenon::logger::logger::context ( ) const

nodiscard

Get the unified context for this logger (const version)

Returns: Const reference to the unified log context

Since: 3.5.0

Definition at line 774 of file logger.cpp.

                                                 {
    return pimpl_->context_;
}

References pimpl_.

◆ enable_metrics_collection()

common::VoidResult kcenon::logger::logger::enable_metrics_collection ( bool enable = true )

Enable or disable metrics collection.

Parameters

enable true to enable metrics collection

Returns: common::VoidResult indicating success or error

Definition at line 603 of file logger.cpp.

                                                              {
    if (!pimpl_) {
        return make_logger_void_result(logger_error_code::invalid_argument, "Logger not initialized");
    }
 
    pimpl_->metrics_enabled_ = enable;
    if (!enable) {
        metrics::g_logger_stats.reset();
    }
 
    return common::ok();
}

References kcenon::logger::metrics::g_logger_stats, kcenon::logger::invalid_argument, kcenon::logger::make_logger_void_result(), kcenon::common::ok(), pimpl_, and kcenon::logger::metrics::logger_performance_stats::reset().

Here is the call graph for this function:

◆ flush()

common::VoidResult kcenon::logger::logger::flush ( )

override

Flush any buffered log messages (ILogger interface)

Returns: VoidResult indicating success or error

Note: Implements common::interfaces::ILogger::flush

Since: 2.0.0

Examples: decorator_usage.cpp, and writer_builder_example.cpp.

Definition at line 574 of file logger.cpp.

                               {
    if (!pimpl_) {
        return common::make_error<std::monostate>(
            static_cast<int>(logger_error_code::invalid_configuration),
            "Logger not initialized",
            "logger_system");
    }
 
    if (pimpl_->async_mode_ && pimpl_->collector_) {
        // Async mode: collector handles both queue draining and writer flushing
        pimpl_->collector_->flush();
    } else {
        // Synchronous mode: manually flush writers
        std::vector<std::shared_ptr<log_writer_interface>> local_writers;
        {
            std::shared_lock<std::shared_mutex> lock(pimpl_->writers_mutex_);
            local_writers = pimpl_->writers_;
        }
 
        for (auto& writer : local_writers) {
            if (writer) {
                writer->flush();
            }
        }
    }
 
    return common::ok();
}

References kcenon::logger::invalid_configuration, kcenon::common::ok(), and pimpl_.

Referenced by example_production_scenarios(), example_production_setup(), kcenon::logger::adapters::logger_adapter::flush(), kcenon::logger::adapters::logger_adapter::shutdown(), and stop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_current_metrics()

result< logger_metrics > kcenon::logger::logger::get_current_metrics ( ) const

Get current performance metrics.

Returns: Result containing metrics or error

Definition at line 620 of file logger.cpp.

                                                         {
    if (!pimpl_) {
        return result<logger_metrics>{
            logger_error_code::invalid_argument,
            "Logger not initialized"};
    }
 
    if (!pimpl_->metrics_enabled_) {
        return result<logger_metrics>{
            logger_error_code::invalid_argument,
            "Metrics collection is not enabled"};
    }
 
    // Return a copy of the current global metrics (thread-safe because of copy constructor)
    // Use static factory method to avoid constructor ambiguity
    return result<logger_metrics>::ok_value(metrics::g_logger_stats);
}

References kcenon::logger::metrics::g_logger_stats, kcenon::logger::invalid_argument, kcenon::logger::result< T >::ok_value(), and pimpl_.

Here is the call graph for this function:

◆ get_emergency_buffer()

const char * kcenon::logger::logger::get_emergency_buffer ( ) const

overridevirtual

Get emergency buffer pointer.

Returns: Pointer to buffer or nullptr

This method must be signal-safe. The buffer contains pending log messages that should be flushed in case of emergency shutdown.

Since: 2.0.0

Implements kcenon::logger::security::critical_logger_interface.

Definition at line 647 of file logger.cpp.

                                               {
    if (!pimpl_) {
        return nullptr;
    }
    return pimpl_->emergency_buffer_;
}

References pimpl_.

◆ get_emergency_buffer_size()

size_t kcenon::logger::logger::get_emergency_buffer_size ( ) const

overridevirtual

Get emergency buffer size.

Returns: Buffer size in bytes

This method must be signal-safe.

Since: 2.0.0

Implements kcenon::logger::security::critical_logger_interface.

Definition at line 654 of file logger.cpp.

                                               {
    if (!pimpl_) {
        return 0;
    }
    return pimpl_->emergency_buffer_used_.load(std::memory_order_acquire);
}

References pimpl_.

◆ get_emergency_fd()

int kcenon::logger::logger::get_emergency_fd ( ) const

overridevirtual

Get file descriptor for emergency writing.

Returns: File descriptor or -1 if not available

This method provides a file descriptor for signal-safe emergency writing. It must be signal-safe (no allocations, no locks).

Since: 2.0.0

Implements kcenon::logger::security::critical_logger_interface.

Definition at line 640 of file logger.cpp.

                                   {
    if (!pimpl_) {
        return -1;
    }
    return pimpl_->emergency_fd_.load(std::memory_order_acquire);
}

References pimpl_.

◆ get_level()

common::interfaces::log_level kcenon::logger::logger::get_level ( ) const

override

Get the current minimum log level (ILogger interface)

Returns: Current minimum log level using common::interfaces::log_level

Note: Implements common::interfaces::ILogger::get_level

Since: 2.0.0

Definition at line 567 of file logger.cpp.

                                                  {
    if (pimpl_) {
        return pimpl_->min_level_.load();
    }
    return common::interfaces::log_level::info;
}

References pimpl_.

Referenced by kcenon::logger::adapters::logger_adapter::get_level().

Here is the caller graph for this function:

◆ get_metrics_collector()

logger_metrics_collector * kcenon::logger::logger::get_metrics_collector ( )

Get metrics collector for direct access.

Returns: Pointer to metrics collector (may be null if not enabled)

◆ get_metrics_history()

result< std::unique_ptr< metrics::logger_performance_stats > > kcenon::logger::logger::get_metrics_history ( std::chrono::seconds duration ) const

Get metrics history for a specific duration.

Parameters

duration How far back to retrieve metrics

Returns: Result containing metrics snapshot or error

◆ get_router() [1/2]

log_router & kcenon::logger::logger::get_router ( )

Definition at line 680 of file logger.cpp.

                               {
    if (!pimpl_) {
        throw std::runtime_error("Logger not initialized");
    }
    std::shared_lock<std::shared_mutex> lock(pimpl_->router_mutex_);
    return *pimpl_->router_;
}

References pimpl_.

◆ get_router() [2/2]

const log_router & kcenon::logger::logger::get_router ( ) const

Get the log router (const version)

Returns: Const reference to the log router

Since: 2.0.0

Definition at line 688 of file logger.cpp.

                                           {
    if (!pimpl_) {
        throw std::runtime_error("Logger not initialized");
    }
    std::shared_lock<std::shared_mutex> lock(pimpl_->router_mutex_);
    return *pimpl_->router_;
}

References pimpl_.

◆ get_sampler() [1/2]

sampling::log_sampler * kcenon::logger::logger::get_sampler ( )

nodiscard

Get the log sampler (if set)

Returns: Pointer to sampler or nullptr if not set

Since: 3.3.0

Definition at line 829 of file logger.cpp.

                                         {
    if (pimpl_) {
        std::shared_lock<std::shared_mutex> lock(pimpl_->sampler_mutex_);
        return pimpl_->sampler_.get();
    }
    return nullptr;
}

References pimpl_.

◆ get_sampler() [2/2]

const sampling::log_sampler * kcenon::logger::logger::get_sampler ( ) const

nodiscard

Get the log sampler (const version)

Returns: Pointer to sampler or nullptr if not set

Since: 3.3.0

Definition at line 837 of file logger.cpp.

                                                     {
    if (pimpl_) {
        std::shared_lock<std::shared_mutex> lock(pimpl_->sampler_mutex_);
        return pimpl_->sampler_.get();
    }
    return nullptr;
}

References pimpl_.

◆ get_sampling_stats()

sampling::sampling_stats kcenon::logger::logger::get_sampling_stats ( ) const

nodiscard

Get sampling statistics.

Returns: Sampling statistics including sampled/dropped counts

Since: 3.3.0

Definition at line 853 of file logger.cpp.

                                                        {
    if (pimpl_) {
        std::shared_lock<std::shared_mutex> lock(pimpl_->sampler_mutex_);
        if (pimpl_->sampler_) {
            return pimpl_->sampler_->get_stats();
        }
    }
    return sampling::sampling_stats{};
}

References pimpl_.

◆ get_writer()

log_writer_interface * kcenon::logger::logger::get_writer ( const std::string & name )

Get a writer by name.

Parameters

name	Name of the writer

Returns: Pointer to writer or nullptr if not found

Definition at line 359 of file logger.cpp.

                                                              {
    if (!pimpl_ || name.empty()) {
        return nullptr;
    }
 
    std::shared_lock<std::shared_mutex> lock(pimpl_->writers_mutex_);
 
    auto it = pimpl_->named_writers_.find(name);
    if (it != pimpl_->named_writers_.end() && it->second) {
        return it->second.get();
    }
 
    return nullptr;
}

References pimpl_.

◆ has_filter()

bool kcenon::logger::logger::has_filter ( ) const

Check if a filter is currently set.

Returns: true if a filter is active, false otherwise

Since: 2.0.0

Definition at line 670 of file logger.cpp.

                              {
    if (!pimpl_) {
        return false;
    }
    std::shared_lock<std::shared_mutex> lock(pimpl_->filter_mutex_);
    return pimpl_->filter_ != nullptr;
}

References pimpl_.

◆ has_routing()

bool kcenon::logger::logger::has_routing ( ) const

Check if routing is enabled.

Returns: true if router has any routes configured

Since: 2.0.0

Definition at line 703 of file logger.cpp.

                               {
    if (!pimpl_) {
        return false;
    }
    std::shared_lock<std::shared_mutex> lock(pimpl_->router_mutex_);
    // Check if router has any routes configured by checking if get_writers_for_log
    // returns anything for a test entry
    return pimpl_->router_ != nullptr;
}

References pimpl_.

◆ has_sampling()

bool kcenon::logger::logger::has_sampling ( ) const

nodiscard

Check if sampling is enabled.

Returns: true if a sampler is set and enabled

Since: 3.3.0

Definition at line 845 of file logger.cpp.

                                {
    if (pimpl_) {
        std::shared_lock<std::shared_mutex> lock(pimpl_->sampler_mutex_);
        return pimpl_->sampler_ != nullptr && pimpl_->sampler_->is_enabled();
    }
    return false;
}

References pimpl_.

◆ is_enabled()

bool kcenon::logger::logger::is_enabled ( common::interfaces::log_level level ) const

override

Check if logging is enabled for the specified level (ILogger interface)

Parameters

level Log level to check using common::interfaces::log_level

Returns: true if logging is enabled for this level

Note: Implements common::interfaces::ILogger::is_enabled

Since: 2.0.0

Definition at line 551 of file logger.cpp.

                                                             {
    return pimpl_ && meets_threshold(level, pimpl_->min_level_.load());
}

References pimpl_.

◆ is_metrics_collection_enabled()

bool kcenon::logger::logger::is_metrics_collection_enabled ( ) const

Check if metrics collection is enabled.

Returns: true if metrics collection is enabled

Definition at line 616 of file logger.cpp.

                                                 {
    return pimpl_ && pimpl_->metrics_enabled_;
}

References pimpl_.

◆ is_running()

bool kcenon::logger::logger::is_running ( ) const

Check if logger is running.

Returns: true if the logger is currently running, false otherwise

In async mode, returns true if the background processing thread is active. In sync mode, always returns true.

Since: 1.0.0

Definition at line 261 of file logger.cpp.

                              {
    return pimpl_ && pimpl_->running_;
}

References pimpl_.

◆ log() [1/3]

common::VoidResult kcenon::logger::logger::log	(	common::interfaces::log_level	level,
		const std::string &	message )

override

Log a message with specified level (ILogger interface)

Parameters

level	Log level using common::interfaces::log_level
message	Log message

Returns: VoidResult indicating success or error

Note: Implements common::interfaces::ILogger::log

Since: 2.0.0

Examples: critical_logging_example.cpp, decorator_usage.cpp, metrics_demo.cpp, and writer_builder_example.cpp.

Definition at line 378 of file logger.cpp.

                                                         {
    if (!pimpl_ || !meets_threshold(level, pimpl_->min_level_.load())) {
        return common::ok();
    }
 
    // Create log entry for filtering and routing
    log_entry entry(level, message);
 
    // Apply filter if set
    {
        std::shared_lock<std::shared_mutex> filter_lock(pimpl_->filter_mutex_);
        if (pimpl_->filter_) {
            if (!pimpl_->filter_->should_log(entry)) {
                return common::ok();  // Message filtered out (not an error)
            }
        }
    }
 
    // Apply sampling if set
    {
        std::shared_lock<std::shared_mutex> sampler_lock(pimpl_->sampler_mutex_);
        if (pimpl_->sampler_ && pimpl_->sampler_->is_enabled()) {
            if (!pimpl_->sampler_->should_sample(entry)) {
                return common::ok();  // Message sampled out (not an error)
            }
        }
    }
 
    // Record metrics if enabled
    auto start_time = std::chrono::high_resolution_clock::now();
 
    // Synchronous path: dispatch with routing support
    pimpl_->dispatch_to_writers(level, message, "", 0, "", entry);
 
    // Update metrics after logging
    if (pimpl_->metrics_enabled_) {
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
        metrics::record_message_logged(duration.count());
    }
 
    return common::ok();
}

References kcenon::common::ok(), pimpl_, and kcenon::logger::metrics::record_message_logged().

Referenced by example_basic_critical_writer(), example_error_handling(), example_hybrid_writer(), example_production_scenarios(), example_production_setup(), example_write_ahead_logging(), generate_logs(), kcenon::logger::adapters::logger_adapter::log(), kcenon::logger::adapters::logger_adapter::log(), kcenon::logger::core::filtered_logger< MinLevel >::log(), kcenon::logger::core::filtered_logger< MinLevel >::log(), kcenon::logger::adapters::logger_adapter::log_entry(), and kcenon::logger::adapters::logger_adapter::log_with_location().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ log() [2/3]

common::VoidResult kcenon::logger::logger::log	(	common::interfaces::log_level	level,
		std::string_view	message,
		const common::source_location &	loc = common::source_location::current() )

override

Log a message with source location (ILogger interface, C++20)

Parameters

level	Log level
message	Log message (string_view for efficiency)
loc	Source location (automatically captured at call site)

Returns: VoidResult indicating success or error

Note: Implements common::interfaces::ILogger::log with source_location

Since: 2.0.0

Definition at line 423 of file logger.cpp.

                                                                 {
    if (!pimpl_ || !meets_threshold(level, pimpl_->min_level_.load())) {
        return common::ok();
    }
 
    std::string msg_str(message);
    std::string file_str(loc.file_name());
    int line = loc.line();
    std::string func_str(loc.function_name());
 
    // Create log entry for filtering and routing
    log_entry entry(level, msg_str, file_str, line, func_str);
 
    // Apply filter if set
    {
        std::shared_lock<std::shared_mutex> filter_lock(pimpl_->filter_mutex_);
        if (pimpl_->filter_) {
            if (!pimpl_->filter_->should_log(entry)) {
                return common::ok();  // Message filtered out
            }
        }
    }
 
    // Apply sampling if set
    {
        std::shared_lock<std::shared_mutex> sampler_lock(pimpl_->sampler_mutex_);
        if (pimpl_->sampler_ && pimpl_->sampler_->is_enabled()) {
            if (!pimpl_->sampler_->should_sample(entry)) {
                return common::ok();  // Message sampled out
            }
        }
    }
 
    // Record metrics if enabled
    auto start_time = std::chrono::high_resolution_clock::now();
 
    // Use async path if in async mode
    if (pimpl_->async_mode_ && pimpl_->collector_) {
        // Enqueue to collector for background processing
        auto now = std::chrono::system_clock::now();
        pimpl_->collector_->enqueue(level, msg_str, file_str, line, func_str, now);
 
        // Update metrics if enabled (async path is much faster)
        if (pimpl_->metrics_enabled_) {
            auto end_time = std::chrono::high_resolution_clock::now();
            auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
            metrics::record_message_logged(duration.count());
        }
        return common::ok();
    }
 
    // Synchronous path: dispatch with routing support
    pimpl_->dispatch_to_writers(level, msg_str, file_str, line, func_str, entry);
 
    // Update metrics after logging
    if (pimpl_->metrics_enabled_) {
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
        metrics::record_message_logged(duration.count());
    }
 
    return common::ok();
}

References kcenon::common::ok(), pimpl_, and kcenon::logger::metrics::record_message_logged().

Here is the call graph for this function:

◆ log() [3/3]

common::VoidResult kcenon::logger::logger::log ( const common::interfaces::log_entry & entry )

override

Log a structured entry (ILogger interface)

Parameters

entry Log entry containing all information

Returns: VoidResult indicating success or error

Note: Implements common::interfaces::ILogger::log(const log_entry&)

Since: 2.0.0

Definition at line 489 of file logger.cpp.

                                                                   {
    if (!pimpl_ || !meets_threshold(entry.level, pimpl_->min_level_.load())) {
        return common::ok();
    }
 
    std::string msg_str(entry.message);
    std::string file_str(entry.file);
    int line = entry.line;
    std::string func_str(entry.function);
 
    // Create log entry for filtering and routing
    log_entry internal_entry(entry.level, msg_str, file_str, line, func_str);
 
    // Apply filter if set
    {
        std::shared_lock<std::shared_mutex> filter_lock(pimpl_->filter_mutex_);
        if (pimpl_->filter_) {
            if (!pimpl_->filter_->should_log(internal_entry)) {
                return common::ok();
            }
        }
    }
 
    // Apply sampling if set
    {
        std::shared_lock<std::shared_mutex> sampler_lock(pimpl_->sampler_mutex_);
        if (pimpl_->sampler_ && pimpl_->sampler_->is_enabled()) {
            if (!pimpl_->sampler_->should_sample(internal_entry)) {
                return common::ok();
            }
        }
    }
 
    // Record metrics if enabled
    auto start_time = std::chrono::high_resolution_clock::now();
 
    // Use async path if in async mode
    if (pimpl_->async_mode_ && pimpl_->collector_) {
        auto now = std::chrono::system_clock::now();
        pimpl_->collector_->enqueue(entry.level, msg_str, file_str, line, func_str, now);
 
        if (pimpl_->metrics_enabled_) {
            auto end_time = std::chrono::high_resolution_clock::now();
            auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
            metrics::record_message_logged(duration.count());
        }
        return common::ok();
    }
 
    // Synchronous path: dispatch with routing support
    pimpl_->dispatch_to_writers(entry.level, msg_str, file_str, line, func_str, internal_entry);
 
    // Update metrics after logging
    if (pimpl_->metrics_enabled_) {
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
        metrics::record_message_logged(duration.count());
    }
 
    return common::ok();
}

References kcenon::common::ok(), pimpl_, and kcenon::logger::metrics::record_message_logged().

Here is the call graph for this function:

◆ log_structured()

structured_log_builder kcenon::logger::logger::log_structured ( log_level level )

nodiscard

Definition at line 717 of file logger.cpp.

                                                             {
    // Get context fields from unified_log_context (thread-safe internally)
    log_fields ctx_fields;
    if (pimpl_ && !pimpl_->context_.empty()) {
        ctx_fields = pimpl_->context_.to_fields();
    }
 
    // Capture by value since we need the fields to outlive this scope
    return structured_log_builder(
        level,
        [this, level](log_entry&& entry) {
            if (!pimpl_ || !meets_threshold(level, pimpl_->min_level_.load())) {
                return;
            }
 
            // Apply filter if set
            {
                std::shared_lock<std::shared_mutex> filter_lock(pimpl_->filter_mutex_);
                if (pimpl_->filter_) {
                    if (!pimpl_->filter_->should_log(entry)) {
                        return;
                    }
                }
            }
 
            // Dispatch to writers
            std::string file_str;
            int line = 0;
            std::string func_str;
            if (entry.location) {
                file_str = entry.location->file.to_string();
                line = entry.location->line;
                func_str = entry.location->function.to_string();
            }
 
            pimpl_->dispatch_to_writers(
                entry.level,
                entry.message.to_string(),
                file_str,
                line,
                func_str,
                entry
            );
        },
        ctx_fields.empty() ? nullptr : &ctx_fields
    );
}

References pimpl_.

◆ remove_writer()

bool kcenon::logger::logger::remove_writer ( const std::string & name )

Remove a writer by name.

Parameters

name	Name of the writer to remove

Returns: true if writer was found and removed

Definition at line 330 of file logger.cpp.

                                                {
    if (!pimpl_ || name.empty()) {
        return false;
    }
 
    std::lock_guard<std::shared_mutex> lock(pimpl_->writers_mutex_);
 
    auto it = pimpl_->named_writers_.find(name);
    if (it == pimpl_->named_writers_.end()) {
        return false;
    }
 
    auto writer_to_remove = it->second;
 
    // Remove from named_writers_ map
    pimpl_->named_writers_.erase(it);
 
    // Remove from writers_ vector
    auto vec_it = std::find(pimpl_->writers_.begin(), pimpl_->writers_.end(), writer_to_remove);
    if (vec_it != pimpl_->writers_.end()) {
        pimpl_->writers_.erase(vec_it);
    }
 
    // Note: Cannot remove from collector's writers list as it doesn't support removal
    // The writer will be skipped during iteration if it's no longer valid
 
    return true;
}

References pimpl_.

◆ reset_metrics()

common::VoidResult kcenon::logger::logger::reset_metrics ( )

Reset performance metrics.

Returns: common::VoidResult indicating success or error

◆ reset_sampling_stats()

void kcenon::logger::logger::reset_sampling_stats ( )

Reset sampling statistics.

Since: 3.3.0

Definition at line 863 of file logger.cpp.

                                  {
    if (pimpl_) {
        std::shared_lock<std::shared_mutex> lock(pimpl_->sampler_mutex_);
        if (pimpl_->sampler_) {
            pimpl_->sampler_->reset_stats();
        }
    }
}

References pimpl_.

◆ set_filter()

void kcenon::logger::logger::set_filter ( std::unique_ptr< log_filter_interface > filter )

Definition at line 663 of file logger.cpp.

                                                                  {
    if (pimpl_) {
        std::lock_guard<std::shared_mutex> lock(pimpl_->filter_mutex_);
        pimpl_->filter_ = std::move(filter);
    }
}

References pimpl_.

◆ set_level()

common::VoidResult kcenon::logger::logger::set_level ( common::interfaces::log_level level )

override

Set the minimum log level (ILogger interface)

Parameters

level Minimum level for messages to be logged

Returns: VoidResult indicating success or error

Note: Implements common::interfaces::ILogger::set_level

Since: 2.0.0

Definition at line 555 of file logger.cpp.

                                                                  {
    if (!pimpl_) {
        return common::make_error<std::monostate>(
            static_cast<int>(logger_error_code::invalid_configuration),
            "Logger not initialized",
            "logger_system");
    }
 
    pimpl_->min_level_.store(level);
    return common::ok();
}

References kcenon::logger::invalid_configuration, kcenon::common::ok(), and pimpl_.

Referenced by kcenon::logger::adapters::logger_adapter::set_level(), and kcenon::logger::adapters::logger_adapter::set_level().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_router()

void kcenon::logger::logger::set_router ( std::unique_ptr< log_router > router )

Set a new log router.

Parameters

router Router to use

Replaces the current router with the provided one. Useful for setting up a pre-configured router.

Since: 2.0.0

Definition at line 696 of file logger.cpp.

                                                        {
    if (pimpl_ && router) {
        std::lock_guard<std::shared_mutex> lock(pimpl_->router_mutex_);
        pimpl_->router_ = std::move(router);
    }
}

References pimpl_.

◆ set_sampler()

void kcenon::logger::logger::set_sampler ( std::unique_ptr< sampling::log_sampler > sampler )

Definition at line 822 of file logger.cpp.

                                                                   {
    if (pimpl_) {
        std::lock_guard<std::shared_mutex> lock(pimpl_->sampler_mutex_);
        pimpl_->sampler_ = std::move(sampler);
    }
}

References pimpl_.

◆ start()

common::VoidResult kcenon::logger::logger::start ( )

Definition at line 222 of file logger.cpp.

                               {
    if (pimpl_ && !pimpl_->running_) {
        pimpl_->running_ = true;
 
        // Start async collector if in async mode
        if (pimpl_->async_mode_ && pimpl_->collector_) {
            // Register all existing writers with the collector
            {
                std::shared_lock<std::shared_mutex> lock(pimpl_->writers_mutex_);
                for (const auto& writer : pimpl_->writers_) {
                    if (writer) {
                        pimpl_->collector_->add_writer(writer);
                    }
                }
            }
 
            // Start the background processing thread
            pimpl_->collector_->start();
        }
    }
    return common::ok();
}

References kcenon::common::ok(), and pimpl_.

Here is the call graph for this function:

◆ stop()

common::VoidResult kcenon::logger::logger::stop ( )

Stop the logger.

Returns: common::VoidResult Success or error code

Stops the background processing thread and flushes all pending messages. This is a blocking operation that waits for all queued messages to be processed.

Note: After stopping, the logger can be restarted with start().

Warning: Stopping the logger may take time if there are many pending messages.

Since: 1.0.0

Definition at line 245 of file logger.cpp.

                              {
    if (pimpl_ && pimpl_->running_) {
        // Stop async collector if in async mode
        // The collector's stop() drains the queue and flushes writers automatically
        if (pimpl_->async_mode_ && pimpl_->collector_) {
            pimpl_->collector_->stop();
        } else {
            // Synchronous mode: manually flush writers
            flush();
        }
 
        pimpl_->running_ = false;
    }
    return common::ok();
}

References flush(), kcenon::common::ok(), and pimpl_.

Referenced by ~logger().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ pimpl_

std::unique_ptr<impl> kcenon::logger::logger::pimpl_

private

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

include/kcenon/logger/core/logger.h
src/core/logger.cpp

Classes

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ logger()

◆ ~logger()

Member Function Documentation

◆ add_writer() [1/2]

◆ add_writer() [2/2]

◆ clear_writers()

◆ context() [1/2]

◆ context() [2/2]

◆ enable_metrics_collection()

◆ flush()

◆ get_current_metrics()

◆ get_emergency_buffer()

◆ get_emergency_buffer_size()

◆ get_emergency_fd()

◆ get_level()

◆ get_metrics_collector()

◆ get_metrics_history()

◆ get_router() [1/2]

◆ get_router() [2/2]

◆ get_sampler() [1/2]

◆ get_sampler() [2/2]

◆ get_sampling_stats()

◆ get_writer()

◆ has_filter()

◆ has_routing()

◆ has_sampling()

◆ is_enabled()

◆ is_metrics_collection_enabled()

◆ is_running()

◆ log() [1/3]

◆ log() [2/3]

◆ log() [3/3]

◆ log_structured()

◆ remove_writer()

◆ reset_metrics()

◆ reset_sampling_stats()

◆ set_filter()

◆ set_level()

◆ set_router()

◆ set_sampler()

◆ start()

◆ stop()

Member Data Documentation

◆ pimpl_