kcenon::common::config::config_loader Class Reference

Loads and validates unified configuration from various sources. More...

#include <config_loader.h>

Collaboration diagram for kcenon::common::config::config_loader:

Static Public Member Functions
static Result< unified_config >	load (const std::string &path)
	Load configuration from a YAML file.
static Result< unified_config >	load_from_string (const std::string &yaml_content)
	Load configuration from a YAML string.
static Result< unified_config >	load_from_env ()
	Load configuration from environment variables only.
static unified_config	defaults ()
	Get default configuration.
static VoidResult	validate (const unified_config &config)
	Validate a configuration.
static std::vector< validation_issue >	get_validation_issues (const unified_config &config)
	Get all validation issues for a configuration.
static std::string	expand_env_vars (const std::string &value)
	Expand environment variables in a string.

Static Private Member Functions
static VoidResult	merge_env_overrides (unified_config &config)
	Apply environment variable overrides to configuration.
static void	apply_env_override (const char *env_name, std::string &target)
static void	apply_env_override (const char *env_name, size_t &target)
static void	apply_env_override (const char *env_name, uint16_t &target)
static void	apply_env_override_bool (const char *env_name, bool &target)
static void	apply_env_override_double (const char *env_name, double &target)
static void	apply_env_override_ms (const char *env_name, std::chrono::milliseconds &target)
static void	apply_env_override_vector (const char *env_name, std::vector< std::string > &target)
static void	validate_thread_config (const thread_config &config, std::vector< validation_issue > &issues)
static void	validate_logger_config (const logger_config &config, std::vector< validation_issue > &issues)
static void	validate_monitoring_config (const monitoring_config &config, std::vector< validation_issue > &issues)
static void	validate_database_config (const database_config &config, std::vector< validation_issue > &issues)
static void	validate_network_config (const network_config &config, std::vector< validation_issue > &issues)

Detailed Description

Loads and validates unified configuration from various sources.

The config_loader supports loading configuration from:

• YAML files (when BUILD_WITH_YAML_CPP is defined)
• Environment variables (UNIFIED_* prefix)
• Programmatic defaults

Usage Example:

// Load from file with environment overrides
auto result = config_loader::load("config.yaml");
if (result.is_ok()) {
    auto config = result.value();
    // Use config...
}
 
// Load from environment only
auto env_result = config_loader::load_from_env();
 
// Get defaults
auto defaults = config_loader::defaults();

Definition at line 94 of file config_loader.h.

Member Function Documentation

apply_env_override() [1/3]

static void kcenon::common::config::config_loader::apply_env_override ( const char * env_name, size_t & target )

inlinestaticprivate

Definition at line 423 of file config_loader.h.

                                                                         {
        const char* value = std::getenv(env_name);
        if (value != nullptr) {
            try {
                target = std::stoull(value);
            } catch (...) {
                // Ignore invalid values
            }
        }
    }

apply_env_override() [2/3]

static void kcenon::common::config::config_loader::apply_env_override ( const char * env_name, std::string & target )

inlinestaticprivate

Definition at line 416 of file config_loader.h.

                                                                            {
        const char* value = std::getenv(env_name);
        if (value != nullptr) {
            target = value;
        }
    }

Referenced by merge_env_overrides().

Here is the caller graph for this function:

apply_env_override() [3/3]

static void kcenon::common::config::config_loader::apply_env_override ( const char * env_name, uint16_t & target )

inlinestaticprivate

Definition at line 434 of file config_loader.h.

                                                                           {
        const char* value = std::getenv(env_name);
        if (value != nullptr) {
            try {
                auto parsed = std::stoul(value);
                if (parsed <= 65535) {
                    target = static_cast<uint16_t>(parsed);
                }
            } catch (...) {
                // Ignore invalid values
            }
        }
    }

apply_env_override_bool()

static void kcenon::common::config::config_loader::apply_env_override_bool ( const char * env_name, bool & target )

inlinestaticprivate

Definition at line 448 of file config_loader.h.

                                                                            {
        const char* value = std::getenv(env_name);
        if (value != nullptr) {
            std::string str_value(value);
            // Convert to lowercase for comparison
            std::transform(str_value.begin(), str_value.end(), str_value.begin(),
                          [](unsigned char c) { return std::tolower(c); });
 
            if (str_value == "true" || str_value == "1" || str_value == "yes" || str_value == "on") {
                target = true;
            } else if (str_value == "false" || str_value == "0" || str_value == "no" || str_value == "off") {
                target = false;
            }
        }
    }

Referenced by merge_env_overrides().

Here is the caller graph for this function:

apply_env_override_double()

static void kcenon::common::config::config_loader::apply_env_override_double ( const char * env_name, double & target )

inlinestaticprivate

Definition at line 464 of file config_loader.h.

                                                                                {
        const char* value = std::getenv(env_name);
        if (value != nullptr) {
            try {
                target = std::stod(value);
            } catch (...) {
                // Ignore invalid values
            }
        }
    }

Referenced by merge_env_overrides().

Here is the caller graph for this function:

apply_env_override_ms()

static void kcenon::common::config::config_loader::apply_env_override_ms ( const char * env_name, std::chrono::milliseconds & target )

inlinestaticprivate

Definition at line 475 of file config_loader.h.

                                                                                           {
        const char* value = std::getenv(env_name);
        if (value != nullptr) {
            try {
                target = std::chrono::milliseconds{std::stoll(value)};
            } catch (...) {
                // Ignore invalid values
            }
        }
    }

Referenced by merge_env_overrides().

Here is the caller graph for this function:

apply_env_override_vector()

static void kcenon::common::config::config_loader::apply_env_override_vector ( const char * env_name, std::vector< std::string > & target )

inlinestaticprivate

Definition at line 486 of file config_loader.h.

                                                                                              {
        const char* value = std::getenv(env_name);
        if (value != nullptr) {
            target.clear();
            std::string str_value(value);
            std::stringstream ss(str_value);
            std::string item;
            while (std::getline(ss, item, ',')) {
                // Trim whitespace
                size_t start = item.find_first_not_of(" \t");
                size_t end = item.find_last_not_of(" \t");
                if (start != std::string::npos && end != std::string::npos) {
                    target.push_back(item.substr(start, end - start + 1));
                }
            }
        }
    }

Referenced by merge_env_overrides().

Here is the caller graph for this function:

defaults()

static unified_config kcenon::common::config::config_loader::defaults ( )

inlinestatic

Get default configuration.

Returns

unified_config with all default values

Definition at line 238 of file config_loader.h.

                                     {
        return unified_config::defaults();
    }

References kcenon::common::config::unified_config::defaults().

Referenced by kcenon::common::config::config_watcher::config_watcher(), load_from_env(), and load_from_string().

Here is the call graph for this function:

Here is the caller graph for this function:

expand_env_vars()

static std::string kcenon::common::config::config_loader::expand_env_vars ( const std::string & value )

inlinestatic

Expand environment variables in a string.

Replaces ${VAR_NAME} patterns with the corresponding environment variable values. If a variable is not set, the pattern is left unchanged.

Parameters

value

String containing environment variable references

Returns

String with environment variables expanded

Definition at line 313 of file config_loader.h.

                                                             {
        static const std::regex env_pattern(R"(\$\{([^}]+)\})");
 
        std::string result = value;
        std::smatch match;
        std::string::const_iterator search_start = result.cbegin();
 
        std::string output;
        size_t last_pos = 0;
 
        while (std::regex_search(search_start, result.cend(), match, env_pattern)) {
            size_t match_pos = static_cast<size_t>(match.position()) +
                              static_cast<size_t>(std::distance(result.cbegin(), search_start));
 
            // Append text before the match
            output += result.substr(last_pos, match_pos - last_pos);
 
            // Get environment variable
            std::string var_name = match[1].str();
            const char* env_value = std::getenv(var_name.c_str());
 
            if (env_value != nullptr) {
                output += env_value;
            } else {
                // Keep the original pattern if variable not found
                output += match[0].str();
            }
 
            last_pos = match_pos + match[0].length();
            search_start = match.suffix().first;
        }
 
        // Append remaining text
        output += result.substr(last_pos);
 
        return output;
    }

Referenced by load_from_string().

Here is the caller graph for this function:

get_validation_issues()

static std::vector< validation_issue > kcenon::common::config::config_loader::get_validation_issues ( const unified_config & config )

inlinestatic

Get all validation issues for a configuration.

Returns both errors and warnings.

Parameters

config

Configuration to validate

Returns

Vector of validation issues

Definition at line 291 of file config_loader.h.

                                                                                           {
        std::vector<validation_issue> issues;
 
        validate_thread_config(config.thread, issues);
        validate_logger_config(config.logger, issues);
        validate_monitoring_config(config.monitoring, issues);
        validate_database_config(config.database, issues);
        validate_network_config(config.network, issues);
 
        return issues;
    }

References kcenon::common::config::unified_config::database, kcenon::common::config::unified_config::logger, kcenon::common::config::unified_config::monitoring, kcenon::common::config::unified_config::network, kcenon::common::config::unified_config::thread, validate_database_config(), validate_logger_config(), validate_monitoring_config(), validate_network_config(), and validate_thread_config().

Here is the call graph for this function:

load()

static Result< unified_config > kcenon::common::config::config_loader::load ( const std::string & path )

inlinestatic

Load configuration from a YAML file.

Loads the configuration from the specified file path, applies environment variable substitution, and merges with environment variable overrides.

Parameters

path	Path to the YAML configuration file

Returns

Result containing unified_config or error

Definition at line 106 of file config_loader.h.

                                                              {
#ifdef BUILD_WITH_YAML_CPP
        // Check if file exists
        if (!std::filesystem::exists(path)) {
            return make_error<unified_config>(
                config_error_codes::file_not_found,
                "Configuration file not found: " + path,
                "config_loader"
            );
        }
 
        try {
            std::ifstream file(path);
            if (!file.is_open()) {
                return make_error<unified_config>(
                    config_error_codes::io_error,
                    "Failed to open configuration file: " + path,
                    "config_loader"
                );
            }
 
            std::stringstream buffer;
            buffer << file.rdbuf();
            return load_from_string(buffer.str());
        } catch (const std::exception& e) {
            return make_error<unified_config>(
                config_error_codes::io_error,
                std::string("Failed to read configuration file: ") + e.what(),
                "config_loader"
            );
        }
#else
        // Without yaml-cpp, we can only load from environment
        (void)path;  // Suppress unused parameter warning
        return make_error<unified_config>(
            config_error_codes::parse_error,
            "YAML support not available. Build with -DBUILD_WITH_YAML_CPP=ON",
            "config_loader"
        );
#endif
    }

References kcenon::common::config::config_error_codes::file_not_found, kcenon::common::config::config_error_codes::io_error, load_from_string(), kcenon::common::make_error(), and kcenon::common::config::config_error_codes::parse_error.

Referenced by kcenon::common::config::config_watcher::config_watcher(), kcenon::common::config::config_watcher::do_reload(), and kcenon::common::config::cli_config_parser::load_with_cli_overrides().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_env()

static Result< unified_config > kcenon::common::config::config_loader::load_from_env ( )

inlinestatic

Load configuration from environment variables only.

Creates a default configuration and applies all UNIFIED_* environment variable overrides.

Returns

Result containing unified_config or error

Definition at line 218 of file config_loader.h.

                                                  {
        unified_config config = defaults();
 
        auto result = merge_env_overrides(config);
        if (result.is_err()) {
            return make_error<unified_config>(result.error());
        }
 
        auto validation_result = validate(config);
        if (validation_result.is_err()) {
            return make_error<unified_config>(validation_result.error());
        }
 
        return Result<unified_config>::ok(std::move(config));
    }

References defaults(), kcenon::common::make_error(), merge_env_overrides(), kcenon::common::Result< T >::ok(), and validate().

Referenced by kcenon::common::config::cli_config_parser::load_with_cli_overrides().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_string()

static Result< unified_config > kcenon::common::config::config_loader::load_from_string ( const std::string & yaml_content )

inlinestatic

Load configuration from a YAML string.

Parses the YAML content, applies environment variable substitution, and merges with environment variable overrides.

Parameters

yaml_content

YAML content as a string

Returns

Result containing unified_config or error

Definition at line 157 of file config_loader.h.

                                                                                  {
#ifdef BUILD_WITH_YAML_CPP
        try {
            // Expand environment variables in the YAML content
            std::string expanded = expand_env_vars(yaml_content);
 
            YAML::Node root = YAML::Load(expanded);
 
            // Start with defaults
            unified_config config = defaults();
 
            // Parse the YAML into config
            auto parse_result = parse_yaml(root, config);
            if (parse_result.is_err()) {
                return make_error<unified_config>(parse_result.error());
            }
 
            // Apply environment variable overrides
            auto env_result = merge_env_overrides(config);
            if (env_result.is_err()) {
                return make_error<unified_config>(env_result.error());
            }
 
            // Validate the configuration
            auto validation_result = validate(config);
            if (validation_result.is_err()) {
                return make_error<unified_config>(validation_result.error());
            }
 
            return Result<unified_config>::ok(std::move(config));
        } catch (const YAML::ParserException& e) {
            return make_error<unified_config>(
                config_error_codes::parse_error,
                std::string("YAML parse error: ") + e.what(),
                "config_loader"
            );
        } catch (const std::exception& e) {
            return make_error<unified_config>(
                config_error_codes::parse_error,
                std::string("Failed to parse configuration: ") + e.what(),
                "config_loader"
            );
        }
#else
        (void)yaml_content;
        return make_error<unified_config>(
            config_error_codes::parse_error,
            "YAML support not available. Build with -DBUILD_WITH_YAML_CPP=ON",
            "config_loader"
        );
#endif
    }

References defaults(), expand_env_vars(), kcenon::common::make_error(), merge_env_overrides(), kcenon::common::Result< T >::ok(), kcenon::common::config::config_error_codes::parse_error, and validate().

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_env_overrides()

static VoidResult kcenon::common::config::config_loader::merge_env_overrides ( unified_config & config )

inlinestaticprivate

Apply environment variable overrides to configuration.

Definition at line 355 of file config_loader.h.

                                                                  {
        // Thread configuration
        apply_env_override("UNIFIED_THREAD_POOL_SIZE", config.thread.pool_size);
        apply_env_override("UNIFIED_THREAD_QUEUE_TYPE", config.thread.queue_type);
        apply_env_override("UNIFIED_THREAD_MAX_QUEUE_SIZE", config.thread.max_queue_size);
        apply_env_override("UNIFIED_THREAD_NAME_PREFIX", config.thread.thread_name_prefix);
 
        // Logger configuration
        apply_env_override("UNIFIED_LOGGER_LEVEL", config.logger.level);
        apply_env_override_bool("UNIFIED_LOGGER_ASYNC", config.logger.async);
        apply_env_override("UNIFIED_LOGGER_BUFFER_SIZE", config.logger.buffer_size);
        apply_env_override("UNIFIED_LOGGER_FILE_PATH", config.logger.file_path);
        apply_env_override("UNIFIED_LOGGER_MAX_FILE_SIZE", config.logger.max_file_size);
        apply_env_override("UNIFIED_LOGGER_MAX_BACKUP_FILES", config.logger.max_backup_files);
        apply_env_override("UNIFIED_LOGGER_FORMAT_PATTERN", config.logger.format_pattern);
        apply_env_override_vector("UNIFIED_LOGGER_WRITERS", config.logger.writers);
 
        // Monitoring configuration
        apply_env_override_bool("UNIFIED_MONITORING_ENABLED", config.monitoring.enabled);
        apply_env_override_ms("UNIFIED_MONITORING_METRICS_INTERVAL_MS", config.monitoring.metrics_interval);
        apply_env_override_ms("UNIFIED_MONITORING_HEALTH_CHECK_INTERVAL_MS", config.monitoring.health_check_interval);
        apply_env_override("UNIFIED_MONITORING_PROMETHEUS_PORT", config.monitoring.prometheus_port);
        apply_env_override("UNIFIED_MONITORING_PROMETHEUS_PATH", config.monitoring.prometheus_path);
 
        // Tracing configuration
        apply_env_override_bool("UNIFIED_MONITORING_TRACING_ENABLED", config.monitoring.tracing.enabled);
        apply_env_override_double("UNIFIED_MONITORING_TRACING_SAMPLING_RATE", config.monitoring.tracing.sampling_rate);
        apply_env_override("UNIFIED_MONITORING_TRACING_EXPORTER", config.monitoring.tracing.exporter);
        apply_env_override("UNIFIED_MONITORING_TRACING_ENDPOINT", config.monitoring.tracing.endpoint);
 
        // Database configuration
        apply_env_override("UNIFIED_DATABASE_BACKEND", config.database.backend);
        apply_env_override("UNIFIED_DATABASE_CONNECTION_STRING", config.database.connection_string);
        apply_env_override_bool("UNIFIED_DATABASE_LOG_QUERIES", config.database.log_queries);
        apply_env_override_ms("UNIFIED_DATABASE_SLOW_QUERY_THRESHOLD_MS", config.database.slow_query_threshold);
        apply_env_override("UNIFIED_DATABASE_POOL_MIN_SIZE", config.database.pool.min_size);
        apply_env_override("UNIFIED_DATABASE_POOL_MAX_SIZE", config.database.pool.max_size);
        apply_env_override_ms("UNIFIED_DATABASE_POOL_IDLE_TIMEOUT_MS", config.database.pool.idle_timeout);
        apply_env_override_ms("UNIFIED_DATABASE_POOL_ACQUIRE_TIMEOUT_MS", config.database.pool.acquire_timeout);
 
        // Network configuration
        apply_env_override("UNIFIED_NETWORK_COMPRESSION", config.network.compression);
        apply_env_override("UNIFIED_NETWORK_BUFFER_SIZE", config.network.buffer_size);
        apply_env_override_ms("UNIFIED_NETWORK_CONNECT_TIMEOUT_MS", config.network.connect_timeout);
        apply_env_override_ms("UNIFIED_NETWORK_IO_TIMEOUT_MS", config.network.io_timeout);
        apply_env_override_ms("UNIFIED_NETWORK_KEEPALIVE_INTERVAL_MS", config.network.keepalive_interval);
        apply_env_override("UNIFIED_NETWORK_MAX_CONNECTIONS", config.network.max_connections);
 
        // TLS configuration
        apply_env_override_bool("UNIFIED_NETWORK_TLS_ENABLED", config.network.tls.enabled);
        apply_env_override("UNIFIED_NETWORK_TLS_VERSION", config.network.tls.version);
        apply_env_override("UNIFIED_NETWORK_TLS_CERT_PATH", config.network.tls.cert_path);
        apply_env_override("UNIFIED_NETWORK_TLS_KEY_PATH", config.network.tls.key_path);
        apply_env_override("UNIFIED_NETWORK_TLS_CA_PATH", config.network.tls.ca_path);
        apply_env_override_bool("UNIFIED_NETWORK_TLS_VERIFY_PEER", config.network.tls.verify_peer);
 
        return VoidResult::ok({});
    }

References kcenon::common::config::pool_config::acquire_timeout, apply_env_override(), apply_env_override_bool(), apply_env_override_double(), apply_env_override_ms(), apply_env_override_vector(), kcenon::common::config::logger_config::async, kcenon::common::config::database_config::backend, kcenon::common::config::logger_config::buffer_size, kcenon::common::config::network_config::buffer_size, kcenon::common::config::tls_config::ca_path, kcenon::common::config::tls_config::cert_path, kcenon::common::config::network_config::compression, kcenon::common::config::network_config::connect_timeout, kcenon::common::config::database_config::connection_string, kcenon::common::config::unified_config::database, kcenon::common::config::monitoring_config::enabled, kcenon::common::config::tls_config::enabled, kcenon::common::config::tracing_config::enabled, kcenon::common::config::tracing_config::endpoint, kcenon::common::config::tracing_config::exporter, kcenon::common::config::logger_config::file_path, kcenon::common::config::logger_config::format_pattern, kcenon::common::config::monitoring_config::health_check_interval, kcenon::common::config::pool_config::idle_timeout, kcenon::common::config::network_config::io_timeout, kcenon::common::config::network_config::keepalive_interval, kcenon::common::config::tls_config::key_path, kcenon::common::config::logger_config::level, kcenon::common::config::database_config::log_queries, kcenon::common::config::unified_config::logger, kcenon::common::config::logger_config::max_backup_files, kcenon::common::config::network_config::max_connections, kcenon::common::config::logger_config::max_file_size, kcenon::common::config::thread_config::max_queue_size, kcenon::common::config::pool_config::max_size, kcenon::common::config::monitoring_config::metrics_interval, kcenon::common::config::pool_config::min_size, kcenon::common::config::unified_config::monitoring, kcenon::common::config::unified_config::network, kcenon::common::Result< T >::ok(), kcenon::common::config::database_config::pool, kcenon::common::config::thread_config::pool_size, kcenon::common::config::monitoring_config::prometheus_path, kcenon::common::config::monitoring_config::prometheus_port, kcenon::common::config::thread_config::queue_type, kcenon::common::config::tracing_config::sampling_rate, kcenon::common::config::database_config::slow_query_threshold, kcenon::common::config::unified_config::thread, kcenon::common::config::thread_config::thread_name_prefix, kcenon::common::config::network_config::tls, kcenon::common::config::monitoring_config::tracing, kcenon::common::config::tls_config::verify_peer, kcenon::common::config::tls_config::version, and kcenon::common::config::logger_config::writers.

Referenced by load_from_env(), and load_from_string().

Here is the call graph for this function:

Here is the caller graph for this function:

validate()

static VoidResult kcenon::common::config::config_loader::validate ( const unified_config & config )

inlinestatic

Validate a configuration.

Checks all configuration values against their allowed ranges and valid options.

Parameters

config

Configuration to validate

Returns

VoidResult indicating success or validation error

Definition at line 251 of file config_loader.h.

                                                             {
        std::vector<validation_issue> issues;
 
        // Validate thread configuration
        validate_thread_config(config.thread, issues);
 
        // Validate logger configuration
        validate_logger_config(config.logger, issues);
 
        // Validate monitoring configuration
        validate_monitoring_config(config.monitoring, issues);
 
        // Validate database configuration
        validate_database_config(config.database, issues);
 
        // Validate network configuration
        validate_network_config(config.network, issues);
 
        // Check for errors (not warnings)
        for (const auto& issue : issues) {
            if (!issue.is_warning) {
                return make_error<std::monostate>(
                    config_error_codes::validation_error,
                    "Validation failed for " + issue.field_path + ": " + issue.message,
                    "config_loader"
                );
            }
        }
 
        return VoidResult::ok({});
    }

References kcenon::common::config::unified_config::database, kcenon::common::config::unified_config::logger, kcenon::common::make_error(), kcenon::common::config::unified_config::monitoring, kcenon::common::config::unified_config::network, kcenon::common::Result< T >::ok(), kcenon::common::config::unified_config::thread, validate_database_config(), validate_logger_config(), validate_monitoring_config(), validate_network_config(), validate_thread_config(), and kcenon::common::config::config_error_codes::validation_error.

Referenced by kcenon::common::config::config_watcher::do_reload(), load_from_env(), load_from_string(), and kcenon::common::config::cli_config_parser::load_with_cli_overrides().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_database_config()

static void kcenon::common::config::config_loader::validate_database_config ( const database_config & config, std::vector< validation_issue > & issues )

inlinestaticprivate

Definition at line 776 of file config_loader.h.

                                                                                                             {
        // Backend validation (if specified)
        if (!config.backend.empty()) {
            static const std::vector<std::string> valid_backends = {"postgresql", "mysql", "sqlite", "mongodb", "redis"};
            if (std::find(valid_backends.begin(), valid_backends.end(), config.backend) == valid_backends.end()) {
                issues.push_back({"database.backend",
                                "Invalid backend: " + config.backend + ". Valid values: postgresql, mysql, sqlite, mongodb, redis",
                                false});
            }
        }
 
        // Pool size validation
        if (config.pool.min_size > config.pool.max_size) {
            issues.push_back({"database.pool",
                            "min_size cannot be greater than max_size",
                            false});
        }
 
        if (config.pool.max_size == 0) {
            issues.push_back({"database.pool.max_size",
                            "Pool max_size must be greater than 0",
                            false});
        }
    }

References kcenon::common::config::database_config::backend, kcenon::common::config::pool_config::max_size, kcenon::common::config::pool_config::min_size, and kcenon::common::config::database_config::pool.

Referenced by get_validation_issues(), and validate().

Here is the caller graph for this function:

validate_logger_config()

static void kcenon::common::config::config_loader::validate_logger_config ( const logger_config & config, std::vector< validation_issue > & issues )

inlinestaticprivate

Definition at line 725 of file config_loader.h.

                                                                                                         {
        // Log level validation
        static const std::vector<std::string> valid_levels = {"trace", "debug", "info", "warn", "error", "critical", "off"};
        if (std::find(valid_levels.begin(), valid_levels.end(), config.level) == valid_levels.end()) {
            issues.push_back({"logger.level",
                            "Invalid log level: " + config.level + ". Valid values: trace, debug, info, warn, error, critical, off",
                            false});
        }
 
        // Writers validation
        static const std::vector<std::string> valid_writers = {"console", "file", "rotating_file", "network", "json"};
        for (const auto& writer : config.writers) {
            if (std::find(valid_writers.begin(), valid_writers.end(), writer) == valid_writers.end()) {
                issues.push_back({"logger.writers",
                                "Invalid writer: " + writer + ". Valid values: console, file, rotating_file, network, json",
                                false});
            }
        }
 
        // Buffer size warning
        if (config.async && config.buffer_size < 1024) {
            issues.push_back({"logger.buffer_size",
                            "Buffer size is very small for async logging. Consider using at least 1024 bytes.",
                            true});
        }
    }

References kcenon::common::config::logger_config::async, kcenon::common::config::logger_config::buffer_size, kcenon::common::config::logger_config::level, and kcenon::common::config::logger_config::writers.

Referenced by get_validation_issues(), and validate().

Here is the caller graph for this function:

validate_monitoring_config()

static void kcenon::common::config::config_loader::validate_monitoring_config ( const monitoring_config & config, std::vector< validation_issue > & issues )

inlinestaticprivate

Definition at line 752 of file config_loader.h.

                                                                                                                 {
        // Sampling rate validation
        if (config.tracing.sampling_rate < 0.0 || config.tracing.sampling_rate > 1.0) {
            issues.push_back({"monitoring.tracing.sampling_rate",
                            "Sampling rate must be between 0.0 and 1.0",
                            false});
        }
 
        // Exporter validation
        static const std::vector<std::string> valid_exporters = {"otlp", "jaeger", "zipkin", "console"};
        if (std::find(valid_exporters.begin(), valid_exporters.end(), config.tracing.exporter) == valid_exporters.end()) {
            issues.push_back({"monitoring.tracing.exporter",
                            "Invalid exporter: " + config.tracing.exporter + ". Valid values: otlp, jaeger, zipkin, console",
                            false});
        }
 
        // Metrics interval warning
        if (config.metrics_interval.count() < 1000) {
            issues.push_back({"monitoring.metrics_interval",
                            "Metrics interval is very short (<1s). This may cause performance issues.",
                            true});
        }
    }

References kcenon::common::config::tracing_config::exporter, kcenon::common::config::monitoring_config::metrics_interval, kcenon::common::config::tracing_config::sampling_rate, and kcenon::common::config::monitoring_config::tracing.

Referenced by get_validation_issues(), and validate().

Here is the caller graph for this function:

validate_network_config()

static void kcenon::common::config::config_loader::validate_network_config ( const network_config & config, std::vector< validation_issue > & issues )

inlinestaticprivate

Definition at line 801 of file config_loader.h.

                                                                                                           {
        // Compression validation
        static const std::vector<std::string> valid_compressions = {"none", "lz4", "gzip", "deflate", "zstd"};
        if (std::find(valid_compressions.begin(), valid_compressions.end(), config.compression) == valid_compressions.end()) {
            issues.push_back({"network.compression",
                            "Invalid compression: " + config.compression + ". Valid values: none, lz4, gzip, deflate, zstd",
                            false});
        }
 
        // TLS version validation
        static const std::vector<std::string> valid_tls_versions = {"1.2", "1.3"};
        if (std::find(valid_tls_versions.begin(), valid_tls_versions.end(), config.tls.version) == valid_tls_versions.end()) {
            issues.push_back({"network.tls.version",
                            "Invalid TLS version: " + config.tls.version + ". Valid values: 1.2, 1.3",
                            false});
        }
 
        // Buffer size warning
        if (config.buffer_size < 4096) {
            issues.push_back({"network.buffer_size",
                            "Buffer size is very small (<4KB). This may cause performance issues.",
                            true});
        }
 
        // TLS certificate validation
        if (config.tls.enabled && config.tls.verify_peer && config.tls.ca_path.empty()) {
            issues.push_back({"network.tls.ca_path",
                            "TLS is enabled with verify_peer but no CA path specified.",
                            true});
        }
    }

References kcenon::common::config::network_config::buffer_size, kcenon::common::config::tls_config::ca_path, kcenon::common::config::network_config::compression, kcenon::common::config::tls_config::enabled, kcenon::common::config::network_config::tls, kcenon::common::config::tls_config::verify_peer, and kcenon::common::config::tls_config::version.

Referenced by get_validation_issues(), and validate().

Here is the caller graph for this function:

validate_thread_config()

static void kcenon::common::config::config_loader::validate_thread_config ( const thread_config & config, std::vector< validation_issue > & issues )

inlinestaticprivate

Definition at line 710 of file config_loader.h.

                                                                                                         {
        // Queue type validation
        static const std::vector<std::string> valid_queue_types = {"mutex", "lockfree", "bounded"};
        if (std::find(valid_queue_types.begin(), valid_queue_types.end(), config.queue_type) == valid_queue_types.end()) {
            issues.push_back({"thread.queue_type",
                            "Invalid queue type: " + config.queue_type + ". Valid values: mutex, lockfree, bounded",
                            false});
        }
 
        // Max queue size validation
        if (config.max_queue_size == 0) {
            issues.push_back({"thread.max_queue_size", "Queue size must be greater than 0", false});
        }
    }

References kcenon::common::config::thread_config::max_queue_size, and kcenon::common::config::thread_config::queue_type.

Referenced by get_validation_issues(), and validate().

Here is the caller graph for this function:

---

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

• include/kcenon/common/config/config_loader.h