performance_strategy.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "config_strategy_interface.h"
#include "../logger_config.h"
 
namespace kcenon::logger {
 
enum class performance_level {
    low_latency,      
    balanced,         
    high_throughput,  
    minimal_overhead  
};
 
class performance_strategy : public config_strategy_interface {
public:
    explicit performance_strategy(performance_level level)
        : level_(level) {}
 
    std::string get_name() const override {
        return "performance:" + level_to_string(level_);
    }
 
    void apply(logger_config& config) const override {
        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;
        }
    }
 
    int priority() const override {
        return 50;  // Medium priority
    }
 
private:
    performance_level level_;
 
    static void apply_low_latency(logger_config& config) {
        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;
    }
 
    static void apply_balanced(logger_config& config) {
        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;
    }
 
    static void apply_high_throughput(logger_config& config) {
        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;
    }
 
    static void apply_minimal_overhead(logger_config& config) {
        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;
    }
 
    static std::string level_to_string(performance_level level) {
        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";
        }
    }
};
 
} // namespace kcenon::logger