High-performance asynchronous writer. More...

#include <high_performance_async_writer.h>

Inheritance diagram for kcenon::logger::async::high_performance_async_writer:

Collaboration diagram for kcenon::logger::async::high_performance_async_writer:

Classes
struct	config
	Configuration for the high-performance async writer. More...

struct	performance_stats
	Performance statistics. More...

struct	queued_log_entry
	Log entry optimized for high-performance queuing. More...

Public Member Functions
	high_performance_async_writer (log_writer_ptr wrapped_writer, const config &cfg=config{})
	Constructor.

	~high_performance_async_writer () override
	Destructor.

bool	start ()
	Start the async writer.

void	stop (bool flush_remaining=true)
	Stop the async writer.

common::VoidResult	write (const log_entry &entry) override
	Write a log entry asynchronously.

common::VoidResult	flush () override
	Flush all pending messages.

bool	is_healthy () const override
	Check if the writer is healthy.

std::string	get_name () const override
	Get the name of this writer.

void	set_use_color (bool use_color) override
	Set whether to use color output.

const performance_stats &	get_stats () const
	Get performance statistics.

void	reset_stats ()
	Reset performance statistics.

double	get_queue_utilization () const
	Get current queue utilization.

const batch_processor::processing_stats *	get_batch_stats () const
	Get batch processor statistics if enabled.

Public Member Functions inherited from kcenon::logger::base_writer
	base_writer (std::unique_ptr< log_formatter_interface > formatter=nullptr)
	Constructor with optional formatter.

virtual	~base_writer ()=default

bool	use_color () const
	Get current color output setting.

log_formatter_interface *	get_formatter () const
	Get the current formatter.

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

virtual common::VoidResult	close ()
	Close the writer and release resources.

virtual auto	is_open () const -> bool
	Check if writer is open and ready.

Private Member Functions
common::VoidResult	write_direct (const log_entry &entry)
	Write directly to the underlying writer (fallback mode)

void	update_stats (bool success, std::chrono::nanoseconds latency)
	Update performance statistics.

batch_processor::batch_entry	to_batch_entry (const queued_log_entry &entry) const
	Convert to batch entry format.

Private Attributes
config	config_

log_writer_ptr	wrapped_writer_

std::unique_ptr< batch_processor >	batch_processor_

std::unique_ptr< memory::object_pool< memory::log_entry_pool::pooled_log_entry > >	memory_pool_

std::atomic< bool >	running_ {false}

performance_stats	stats_

Additional Inherited Members
Protected Member Functions inherited from kcenon::logger::base_writer
std::string	format_log_entry (const log_entry &entry) const
	Format a log entry using the current formatter.

Detailed Description

High-performance asynchronous writer.

This writer combines lock-free queuing, memory pooling, and batch processing to achieve maximum throughput while maintaining low latency.

Definition at line 36 of file high_performance_async_writer.h.

Constructor & Destructor Documentation

◆ high_performance_async_writer()

kcenon::logger::async::high_performance_async_writer::high_performance_async_writer	(	log_writer_ptr	wrapped_writer,
		const config &	cfg = config{} )

explicit

Constructor.

Parameters

wrapped_writer	The underlying writer to wrap
cfg	Configuration

Definition at line 10 of file high_performance_async_writer.cpp.

    : config_(cfg)
    , wrapped_writer_(std::move(wrapped_writer)) {
 
    if (!wrapped_writer_) {
        throw std::invalid_argument("Wrapped writer cannot be null");
    }
 
    // Initialize memory pool if enabled
    if (config_.enable_memory_pooling) {
        memory_pool_ = std::make_unique<memory::object_pool<memory::log_entry_pool::pooled_log_entry>>(
            config_.pool_config);
    }
 
    // Initialize batch processor if enabled
    if (config_.enable_batch_processing) {
        batch_processor_ = make_batch_processor(
            log_writer_ptr(wrapped_writer_.release()),
            config_.batch_config);
    }
}

References config_, kcenon::logger::async::high_performance_async_writer::config::enable_batch_processing, kcenon::logger::async::high_performance_async_writer::config::enable_memory_pooling, and wrapped_writer_.

◆ ~high_performance_async_writer()

kcenon::logger::async::high_performance_async_writer::~high_performance_async_writer ( )

override

Destructor.

Definition at line 34 of file high_performance_async_writer.cpp.

                                                              {
    stop(true);
}

References stop().

Here is the call graph for this function:

Member Function Documentation

◆ flush()

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

overridevirtual

Flush all pending messages.

Returns: common::VoidResult indicating success or error

Implements kcenon::logger::base_writer.

Definition at line 103 of file high_performance_async_writer.cpp.

                                                      {
    if (batch_processor_) {
        batch_processor_->flush();
    } else if (wrapped_writer_) {
        return wrapped_writer_->flush();
    }
    return common::ok();
}

References batch_processor_, kcenon::common::ok(), and wrapped_writer_.

Here is the call graph for this function:

◆ get_batch_stats()

const batch_processor::processing_stats * kcenon::logger::async::high_performance_async_writer::get_batch_stats ( ) const

Get batch processor statistics if enabled.

Returns: Pointer to batch processor stats, or nullptr if not enabled

Definition at line 144 of file high_performance_async_writer.cpp.

                                                                                            {
    if (batch_processor_) {
        return &batch_processor_->get_stats();
    }
    return nullptr;
}

References batch_processor_.

◆ get_name()

std::string kcenon::logger::async::high_performance_async_writer::get_name ( ) const

overridevirtual

Get the name of this writer.

Returns: Writer name

Implements kcenon::logger::base_writer.

Definition at line 124 of file high_performance_async_writer.cpp.

                                                        {
    const std::string base_name = wrapped_writer_ ? wrapped_writer_->get_name() : "unknown";
    return "high_perf_async_" + base_name;
}

References wrapped_writer_.

◆ get_queue_utilization()

double kcenon::logger::async::high_performance_async_writer::get_queue_utilization ( ) const

Get current queue utilization.

Returns: Queue utilization as percentage (0.0 to 1.0)

Definition at line 135 of file high_performance_async_writer.cpp.

                                                                  {
    if (batch_processor_) {
        const auto queue_size = batch_processor_->get_queue_size();
        const auto max_size = config_.queue_size;
        return static_cast<double>(queue_size) / max_size;
    }
    return 0.0;
}

References batch_processor_, config_, and kcenon::logger::async::high_performance_async_writer::config::queue_size.

◆ get_stats()

const performance_stats & kcenon::logger::async::high_performance_async_writer::get_stats ( ) const

inline

Get performance statistics.

Returns: Reference to performance statistics

Definition at line 165 of file high_performance_async_writer.h.

165{ return stats_; }

kcenon::logger::async::high_performance_async_writer::stats_

performance_stats stats_

Definition high_performance_async_writer.h:243

References stats_.

◆ is_healthy()

bool kcenon::logger::async::high_performance_async_writer::is_healthy ( ) const

overridevirtual

Check if the writer is healthy.

Returns: true if healthy, false otherwise

Reimplemented from kcenon::logger::base_writer.

Definition at line 112 of file high_performance_async_writer.cpp.

                                                     {
    if (!running_.load(std::memory_order_relaxed)) {
        return false;
    }
 
    if (batch_processor_) {
        return batch_processor_->is_healthy();
    }
 
    return wrapped_writer_ && wrapped_writer_->is_healthy();
}

References batch_processor_, running_, and wrapped_writer_.

◆ reset_stats()

void kcenon::logger::async::high_performance_async_writer::reset_stats ( )

inline

Reset performance statistics.

Definition at line 170 of file high_performance_async_writer.h.

170{ stats_.reset(); }

kcenon::logger::async::high_performance_async_writer::performance_stats::reset

void reset()

Definition high_performance_async_writer.h:92

References kcenon::logger::async::high_performance_async_writer::performance_stats::reset(), and stats_.

Here is the call graph for this function:

◆ set_use_color()

void kcenon::logger::async::high_performance_async_writer::set_use_color ( bool use_color )

overridevirtual

Set whether to use color output.

Parameters

use_color Enable/disable color output

Reimplemented from kcenon::logger::base_writer.

Definition at line 129 of file high_performance_async_writer.cpp.

                                                                {
    // Color setting is now handled by formatter, not writer interface
    // This method is kept for backward compatibility but is deprecated
    (void)use_color;  // Suppress unused parameter warning
}

References kcenon::logger::base_writer::use_color().

Here is the call graph for this function:

◆ start()

bool kcenon::logger::async::high_performance_async_writer::start ( )

Start the async writer.

Returns: true if started successfully

Definition at line 38 of file high_performance_async_writer.cpp.

                                          {
    bool expected = false;
    if (!running_.compare_exchange_strong(expected, true)) {
        return false; // Already running
    }
 
    if (batch_processor_) {
        return batch_processor_->start();
    }
 
    return true;
}

References batch_processor_, and running_.

◆ stop()

void kcenon::logger::async::high_performance_async_writer::stop ( bool flush_remaining = true )

Stop the async writer.

Parameters

flush_remaining Whether to flush remaining messages

Definition at line 51 of file high_performance_async_writer.cpp.

                                                             {
    if (!running_.exchange(false)) {
        return; // Already stopped
    }
 
    if (batch_processor_) {
        batch_processor_->stop(flush_remaining);
    } else if (flush_remaining && wrapped_writer_) {
        wrapped_writer_->flush();
    }
}

References batch_processor_, running_, and wrapped_writer_.

Referenced by ~high_performance_async_writer().

Here is the caller graph for this function:

◆ to_batch_entry()

batch_processor::batch_entry kcenon::logger::async::high_performance_async_writer::to_batch_entry ( const queued_log_entry & entry ) const

private

Convert to batch entry format.

Definition at line 189 of file high_performance_async_writer.cpp.

                                         {
    return batch_processor::batch_entry(
        entry.level,
        entry.message,
        entry.file,
        entry.line,
        entry.function,
        entry.timestamp);
}

References kcenon::logger::async::high_performance_async_writer::queued_log_entry::file, kcenon::logger::async::high_performance_async_writer::queued_log_entry::function, kcenon::logger::async::high_performance_async_writer::queued_log_entry::level, kcenon::logger::async::high_performance_async_writer::queued_log_entry::line, kcenon::logger::async::high_performance_async_writer::queued_log_entry::message, and kcenon::logger::async::high_performance_async_writer::queued_log_entry::timestamp.

◆ update_stats()

void kcenon::logger::async::high_performance_async_writer::update_stats	(	bool	success,
		std::chrono::nanoseconds	latency )

private

Update performance statistics.

Definition at line 167 of file high_performance_async_writer.cpp.

                                                                                           {
    if (success) {
        stats_.successful_writes.fetch_add(1, std::memory_order_relaxed);
    }
 
    // Update average latency using exponential moving average
    const double latency_us = std::chrono::duration_cast<std::chrono::microseconds>(latency).count();
    const double alpha = 0.1; // Smoothing factor
    const double current_avg = stats_.average_latency_us.load(std::memory_order_relaxed);
    const double new_avg = alpha * latency_us + (1.0 - alpha) * current_avg;
    stats_.average_latency_us.store(new_avg, std::memory_order_relaxed);
 
    // Update throughput
    const auto now = std::chrono::steady_clock::now();
    const auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - stats_.start_time).count();
    if (elapsed > 0) {
        const auto total_writes = stats_.total_writes.load(std::memory_order_relaxed);
        const double throughput = static_cast<double>(total_writes) / elapsed;
        stats_.throughput_per_second.store(throughput, std::memory_order_relaxed);
    }
}

References kcenon::logger::async::high_performance_async_writer::performance_stats::average_latency_us, kcenon::logger::async::high_performance_async_writer::performance_stats::start_time, stats_, kcenon::logger::success, kcenon::logger::async::high_performance_async_writer::performance_stats::successful_writes, kcenon::logger::async::high_performance_async_writer::performance_stats::throughput_per_second, and kcenon::logger::async::high_performance_async_writer::performance_stats::total_writes.

Referenced by write(), and write_direct().

Here is the caller graph for this function:

◆ write()

common::VoidResult kcenon::logger::async::high_performance_async_writer::write ( const log_entry & entry )

overridevirtual

Write a log entry asynchronously.

Parameters

entry The log entry to write

Returns: common::VoidResult indicating success or error

Since: 3.5.0 Changed to use log_entry directly

Implements kcenon::logger::base_writer.

Definition at line 63 of file high_performance_async_writer.cpp.

                                                                            {
 
    const auto start_time = std::chrono::steady_clock::now();
 
    if (!running_.load(std::memory_order_relaxed)) {
        return write_direct(entry);
    }
 
    stats_.total_writes.fetch_add(1, std::memory_order_relaxed);
 
    // Use batch processor if available
    if (batch_processor_) {
        // Convert log_level from logger_system to common::interfaces
        auto level = static_cast<common::interfaces::log_level>(static_cast<int>(entry.level));
 
        // Construct batch_entry directly with to_string() rvalues to avoid copies
        batch_processor::batch_entry batch_entry(
            level,
            entry.message.to_string(),
            entry.location ? entry.location->file.to_string() : std::string{},
            entry.location ? entry.location->line : 0,
            entry.location ? entry.location->function.to_string() : std::string{},
            entry.timestamp);
 
        if (batch_processor_->add_entry(std::move(batch_entry))) {
            const auto end_time = std::chrono::steady_clock::now();
            const auto latency = end_time - start_time;
            update_stats(true, latency);
            return common::ok();
        } else {
            stats_.dropped_writes.fetch_add(1, std::memory_order_relaxed);
            // Fall back to direct write
            return write_direct(entry);
        }
    }
 
    // Direct async write (fallback mode)
    return write_direct(entry);
}

References batch_processor_, kcenon::logger::async::high_performance_async_writer::performance_stats::dropped_writes, kcenon::logger::log_entry::level, kcenon::logger::log_entry::location, kcenon::logger::log_entry::message, kcenon::common::ok(), running_, stats_, kcenon::logger::log_entry::timestamp, kcenon::logger::small_string< SSO_SIZE >::to_string(), kcenon::logger::async::high_performance_async_writer::performance_stats::total_writes, update_stats(), and write_direct().

Here is the call graph for this function:

◆ write_direct()

common::VoidResult kcenon::logger::async::high_performance_async_writer::write_direct ( const log_entry & entry )

private

Write directly to the underlying writer (fallback mode)

Definition at line 151 of file high_performance_async_writer.cpp.

                                                                                   {
 
    if (!wrapped_writer_) {
        return make_logger_void_result(logger_error_code::writer_not_available, "No wrapped writer available");
    }
 
    const auto start_time = std::chrono::steady_clock::now();
    auto result = wrapped_writer_->write(entry);
    const auto end_time = std::chrono::steady_clock::now();
 
    const auto latency = end_time - start_time;
    update_stats(result.is_ok(), latency);
 
    return result;
}