kcenon::logger::performance_strategy Class Reference

Configuration strategy for performance tuning. More...

#include <performance_strategy.h>

Inheritance diagram for kcenon::logger::performance_strategy:

Collaboration diagram for kcenon::logger::performance_strategy:

Public Member Functions
	performance_strategy (performance_level level)
	Constructor with performance level.
std::string	get_name () const override
	Get the strategy name.
void	apply (logger_config &config) const override
	Apply this strategy to a logger configuration.
int	priority () const override
	Get the strategy priority.
Public Member Functions inherited from kcenon::logger::config_strategy_interface
virtual	~config_strategy_interface ()=default
virtual bool	is_applicable () const
	Check if this strategy is applicable in the current context.

Static Private Member Functions
static void	apply_low_latency (logger_config &config)
static void	apply_balanced (logger_config &config)
static void	apply_high_throughput (logger_config &config)
static void	apply_minimal_overhead (logger_config &config)
static std::string	level_to_string (performance_level level)

Private Attributes
performance_level	level_

Detailed Description

Configuration strategy for performance tuning.

Applies performance-optimized settings based on the selected level. Each level is optimized for specific use cases.

Since

2.0.0

Definition at line 44 of file performance_strategy.h.

Constructor & Destructor Documentation

performance_strategy()

kcenon::logger::performance_strategy::performance_strategy ( performance_level level )

inlineexplicit

Constructor with performance level.

Parameters

level

The performance tuning level to apply

Definition at line 50 of file performance_strategy.h.

        : level_(level) {}

Member Function Documentation

apply()

void kcenon::logger::performance_strategy::apply ( logger_config & config ) const

inlineoverridevirtual

Apply this strategy to a logger configuration.

Parameters

config

The configuration to modify

Modifies the provided configuration according to the strategy's rules. Changes are applied in-place.

Implements kcenon::logger::config_strategy_interface.

Definition at line 57 of file performance_strategy.h.

                                                     {
        switch (level_) {
        case performance_level::low_latency:
            apply_low_latency(config);
            break;
        case performance_level::balanced:
            apply_balanced(config);
            break;
        case performance_level::high_throughput:
            apply_high_throughput(config);
            break;
        case performance_level::minimal_overhead:
            apply_minimal_overhead(config);
            break;
        }
    }

References apply_balanced(), apply_high_throughput(), apply_low_latency(), apply_minimal_overhead(), kcenon::logger::balanced, kcenon::logger::high_throughput, level_, kcenon::logger::low_latency, and kcenon::logger::minimal_overhead.

Here is the call graph for this function:

apply_balanced()

static void kcenon::logger::performance_strategy::apply_balanced ( logger_config & config )

inlinestaticprivate

Definition at line 92 of file performance_strategy.h.

                                                      {
        config.async = true;
        config.buffer_size = 8192;
        config.batch_size = 100;
        config.flush_interval = std::chrono::milliseconds(1000);
        config.use_lock_free = false;
        config.max_queue_size = 10000;
        config.queue_overflow_policy = logger_config::overflow_policy::drop_newest;
        config.enable_batch_writing = true;
    }

References kcenon::logger::logger_config::async, kcenon::logger::logger_config::batch_size, kcenon::logger::logger_config::buffer_size, kcenon::logger::logger_config::enable_batch_writing, kcenon::logger::logger_config::flush_interval, kcenon::logger::logger_config::max_queue_size, kcenon::logger::logger_config::queue_overflow_policy, and kcenon::logger::logger_config::use_lock_free.

Referenced by apply().

Here is the caller graph for this function:

apply_high_throughput()

static void kcenon::logger::performance_strategy::apply_high_throughput ( logger_config & config )

inlinestaticprivate

Definition at line 103 of file performance_strategy.h.

                                                             {
        config.async = true;
        config.buffer_size = 65536;
        config.batch_size = 500;
        config.flush_interval = std::chrono::milliseconds(5000);
        config.use_lock_free = true;
        config.max_queue_size = 100000;
        config.queue_overflow_policy = logger_config::overflow_policy::drop_oldest;
        config.writer_thread_count = 2;
        config.enable_compression = true;
        config.enable_batch_writing = true;
    }

References kcenon::logger::logger_config::async, kcenon::logger::logger_config::batch_size, kcenon::logger::logger_config::buffer_size, kcenon::logger::logger_config::enable_batch_writing, kcenon::logger::logger_config::enable_compression, kcenon::logger::logger_config::flush_interval, kcenon::logger::logger_config::max_queue_size, kcenon::logger::logger_config::queue_overflow_policy, kcenon::logger::logger_config::use_lock_free, and kcenon::logger::logger_config::writer_thread_count.

Referenced by apply().

Here is the caller graph for this function:

apply_low_latency()

static void kcenon::logger::performance_strategy::apply_low_latency ( logger_config & config )

inlinestaticprivate

Definition at line 81 of file performance_strategy.h.

                                                         {
        config.async = true;
        config.buffer_size = 4096;
        config.batch_size = 10;
        config.flush_interval = std::chrono::milliseconds(10);
        config.use_lock_free = true;
        config.max_queue_size = 10000;
        config.queue_overflow_policy = logger_config::overflow_policy::drop_oldest;
        config.enable_batch_writing = false;
    }

References kcenon::logger::logger_config::async, kcenon::logger::logger_config::batch_size, kcenon::logger::logger_config::buffer_size, kcenon::logger::logger_config::enable_batch_writing, kcenon::logger::logger_config::flush_interval, kcenon::logger::logger_config::max_queue_size, kcenon::logger::logger_config::queue_overflow_policy, and kcenon::logger::logger_config::use_lock_free.

Referenced by apply().

Here is the caller graph for this function:

apply_minimal_overhead()

static void kcenon::logger::performance_strategy::apply_minimal_overhead ( logger_config & config )

inlinestaticprivate

Definition at line 116 of file performance_strategy.h.

                                                              {
        config.async = true;
        config.buffer_size = 4096;
        config.batch_size = 50;
        config.flush_interval = std::chrono::milliseconds(2000);
        config.enable_metrics = false;
        config.enable_structured_logging = false;
        config.enable_source_location = false;
        config.enable_color_output = false;
        config.enable_batch_writing = true;
    }

References kcenon::logger::logger_config::async, kcenon::logger::logger_config::batch_size, kcenon::logger::logger_config::buffer_size, kcenon::logger::logger_config::enable_batch_writing, kcenon::logger::logger_config::enable_color_output, kcenon::logger::logger_config::enable_metrics, kcenon::logger::logger_config::enable_source_location, kcenon::logger::logger_config::enable_structured_logging, and kcenon::logger::logger_config::flush_interval.

Referenced by apply().

Here is the caller graph for this function:

get_name()

std::string kcenon::logger::performance_strategy::get_name ( ) const

inlineoverridevirtual

Get the strategy name.

Returns

Human-readable strategy name

Implements kcenon::logger::config_strategy_interface.

Definition at line 53 of file performance_strategy.h.

                                        {
        return "performance:" + level_to_string(level_);
    }

References level_, and level_to_string().

Here is the call graph for this function:

level_to_string()

static std::string kcenon::logger::performance_strategy::level_to_string ( performance_level level )

inlinestaticprivate

Definition at line 128 of file performance_strategy.h.

                                                              {
        switch (level) {
        case performance_level::low_latency: return "low_latency";
        case performance_level::balanced: return "balanced";
        case performance_level::high_throughput: return "high_throughput";
        case performance_level::minimal_overhead: return "minimal_overhead";
        default: return "unknown";
        }
    }

References kcenon::logger::balanced, kcenon::logger::high_throughput, kcenon::logger::low_latency, and kcenon::logger::minimal_overhead.

Referenced by get_name().

Here is the caller graph for this function:

priority()

int kcenon::logger::performance_strategy::priority ( ) const

inlineoverridevirtual

Get the strategy priority.

Returns

Priority value (higher = applied first)

When multiple strategies are applied, they are sorted by priority (descending) before application.

Reimplemented from kcenon::logger::config_strategy_interface.

Definition at line 74 of file performance_strategy.h.

                                  {
        return 50;  // Medium priority
    }

Member Data Documentation

level_

performance_level kcenon::logger::performance_strategy::level_

private

Definition at line 79 of file performance_strategy.h.

Referenced by apply(), and get_name().

---

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

• include/kcenon/logger/core/strategies/performance_strategy.h