kcenon::logger::environment_strategy Class Reference

Configuration strategy based on environment variables. More...

#include <environment_strategy.h>

Inheritance diagram for kcenon::logger::environment_strategy:

Collaboration diagram for kcenon::logger::environment_strategy:

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

Static Private Member Functions
static log_level	parse_log_level (const char *str)
static bool	parse_bool (const char *str)
static std::size_t	parse_size (const char *str, std::size_t default_value)

Detailed Description

Configuration strategy based on environment variables.

Reads environment variables and applies corresponding settings to the logger configuration. Useful for containerized deployments where configuration is passed via environment.

Since

2.0.0

Definition at line 40 of file environment_strategy.h.

Member Function Documentation

apply()

void kcenon::logger::environment_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 46 of file environment_strategy.h.

                                                     {
        // LOG_LEVEL
        if (const char* level = std::getenv("LOG_LEVEL")) {
            config.min_level = parse_log_level(level);
        }
 
        // LOG_ASYNC
        if (const char* async_str = std::getenv("LOG_ASYNC")) {
            config.async = parse_bool(async_str);
            if (!config.async && config.batch_size > 1) {
                config.batch_size = 1;
            }
        }
 
        // LOG_BUFFER_SIZE
        if (const char* buffer = std::getenv("LOG_BUFFER_SIZE")) {
            config.buffer_size = parse_size(buffer, config.buffer_size);
        }
 
        // LOG_BATCH_SIZE
        if (const char* batch = std::getenv("LOG_BATCH_SIZE")) {
            config.batch_size = parse_size(batch, config.batch_size);
        }
 
        // LOG_FLUSH_INTERVAL
        if (const char* interval = std::getenv("LOG_FLUSH_INTERVAL")) {
            config.flush_interval = std::chrono::milliseconds(
                parse_size(interval, static_cast<std::size_t>(config.flush_interval.count()))
            );
        }
 
        // LOG_COLOR
        if (const char* color = std::getenv("LOG_COLOR")) {
            config.enable_color_output = parse_bool(color);
        }
 
        // LOG_METRICS
        if (const char* metrics = std::getenv("LOG_METRICS")) {
            config.enable_metrics = parse_bool(metrics);
        }
 
        // LOG_STRUCTURED
        if (const char* structured = std::getenv("LOG_STRUCTURED")) {
            config.enable_structured_logging = parse_bool(structured);
        }
 
        // LOG_CRASH_HANDLER
        if (const char* crash = std::getenv("LOG_CRASH_HANDLER")) {
            config.enable_crash_handler = parse_bool(crash);
        }
 
        // LOG_MAX_QUEUE_SIZE
        if (const char* queue = std::getenv("LOG_MAX_QUEUE_SIZE")) {
            config.max_queue_size = parse_size(queue, config.max_queue_size);
        }
 
        // LOG_BATCH_WRITING
        if (const char* batch_write = std::getenv("LOG_BATCH_WRITING")) {
            config.enable_batch_writing = parse_bool(batch_write);
        }
    }

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_crash_handler, kcenon::logger::logger_config::enable_metrics, kcenon::logger::logger_config::enable_structured_logging, kcenon::logger::logger_config::flush_interval, kcenon::logger::logger_config::max_queue_size, kcenon::logger::logger_config::min_level, parse_bool(), parse_log_level(), and parse_size().

Here is the call graph for this function:

get_name()

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

inlineoverridevirtual

Get the strategy name.

Returns

Human-readable strategy name

Implements kcenon::logger::config_strategy_interface.

Definition at line 42 of file environment_strategy.h.

                                        {
        return "environment";
    }

is_applicable()

bool kcenon::logger::environment_strategy::is_applicable ( ) const

inlineoverridevirtual

Check if this strategy is applicable in the current context.

Returns

true if the strategy should be applied

Override to implement conditional strategy application (e.g., only apply in certain environments).

Reimplemented from kcenon::logger::config_strategy_interface.

Definition at line 108 of file environment_strategy.h.

                                        {
        // Applicable if any relevant environment variable is set
        return std::getenv("LOG_LEVEL") != nullptr ||
               std::getenv("LOG_ASYNC") != nullptr ||
               std::getenv("LOG_BUFFER_SIZE") != nullptr ||
               std::getenv("LOG_BATCH_SIZE") != nullptr ||
               std::getenv("LOG_FLUSH_INTERVAL") != nullptr ||
               std::getenv("LOG_COLOR") != nullptr ||
               std::getenv("LOG_METRICS") != nullptr;
    }

parse_bool()

static bool kcenon::logger::environment_strategy::parse_bool ( const char * str )

inlinestaticprivate

Definition at line 139 of file environment_strategy.h.

                                            {
        std::string value(str);
        std::transform(value.begin(), value.end(), value.begin(), ::tolower);
        return value == "true" || value == "1" || value == "yes" || value == "on";
    }

Referenced by apply().

Here is the caller graph for this function:

parse_log_level()

static log_level kcenon::logger::environment_strategy::parse_log_level ( const char * str )

inlinestaticprivate

Definition at line 125 of file environment_strategy.h.

                                                      {
        std::string level_str(str);
        std::transform(level_str.begin(), level_str.end(), level_str.begin(), ::tolower);
 
        if (level_str == "trace") return log_level::trace;
        if (level_str == "debug") return log_level::debug;
        if (level_str == "info") return log_level::info;
        if (level_str == "warn" || level_str == "warning") return log_level::warning;
        if (level_str == "error") return log_level::error;
        if (level_str == "fatal" || level_str == "critical") return log_level::critical;
 
        return log_level::info;  // Default
    }

Referenced by apply().

Here is the caller graph for this function:

parse_size()

static std::size_t kcenon::logger::environment_strategy::parse_size ( const char * str, std::size_t default_value )

inlinestaticprivate

Definition at line 145 of file environment_strategy.h.

                                                                          {
        try {
            return std::stoull(str);
        } catch (...) {
            return default_value;
        }
    }

Referenced by apply().

Here is the caller graph for this function:

priority()

int kcenon::logger::environment_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 119 of file environment_strategy.h.

                                  {
        // High priority - environment overrides other strategies
        return 100;
    }

---

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

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