unified_config.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 <chrono>
#include <optional>
#include <string>
#include <vector>
 
namespace kcenon::common::config {
 
struct thread_config {
    size_t pool_size = 0;  // 0 means auto-detect
 
    std::string queue_type = "lockfree";
 
    size_t max_queue_size = 10000;
 
    std::string thread_name_prefix = "worker";
};
 
struct logger_config {
    std::string level = "info";
 
    std::vector<std::string> writers = {"console"};
 
    bool async = true;
 
    size_t buffer_size = 8192;
 
    std::string file_path = "./logs/app.log";
 
    size_t max_file_size = 10 * 1024 * 1024;  // 10MB
 
    size_t max_backup_files = 5;
 
    std::string format_pattern = "[%Y-%m-%d %H:%M:%S.%e] [%l] [%t] %v";
};
 
struct tracing_config {
    bool enabled = false;
 
    double sampling_rate = 0.1;
 
    std::string exporter = "otlp";
 
    std::string endpoint = "http://localhost:4317";
};
 
struct monitoring_config {
    bool enabled = true;
 
    std::chrono::milliseconds metrics_interval{5000};
 
    std::chrono::milliseconds health_check_interval{30000};
 
    tracing_config tracing;
 
    uint16_t prometheus_port = 9090;
 
    std::string prometheus_path = "/metrics";
};
 
struct pool_config {
    size_t min_size = 5;
 
    size_t max_size = 20;
 
    std::chrono::milliseconds idle_timeout{60000};
 
    std::chrono::milliseconds acquire_timeout{5000};
};
 
struct database_config {
    std::string backend;
 
    std::string connection_string;
 
    pool_config pool;
 
    bool log_queries = false;
 
    std::chrono::milliseconds slow_query_threshold{1000};
};
 
struct tls_config {
    bool enabled = true;
 
    std::string version = "1.3";
 
    std::string cert_path;
 
    std::string key_path;
 
    std::string ca_path;
 
    bool verify_peer = true;
};
 
struct network_config {
    tls_config tls;
 
    std::string compression = "lz4";
 
    size_t buffer_size = 65536;
 
    std::chrono::milliseconds connect_timeout{5000};
 
    std::chrono::milliseconds io_timeout{30000};
 
    std::chrono::milliseconds keepalive_interval{15000};
 
    size_t max_connections = 10000;
};
 
struct unified_config {
    thread_config thread;
 
    logger_config logger;
 
    monitoring_config monitoring;
 
    database_config database;
 
    network_config network;
 
    static unified_config defaults() {
        return unified_config{};
    }
};
 
constexpr const char* ENV_PREFIX = "UNIFIED_";
 
struct field_metadata {
    std::string path;
 
    std::string description;
 
    bool hot_reloadable = false;
 
    std::string env_var;
 
    std::vector<std::string> allowed_values;
};
 
inline std::vector<field_metadata> get_config_metadata() {
    return {
        // Thread configuration
        {"thread.pool_size", "Number of worker threads (0 for auto)", false,
         "UNIFIED_THREAD_POOL_SIZE", {}},
        {"thread.queue_type", "Task queue type", false,
         "UNIFIED_THREAD_QUEUE_TYPE", {"mutex", "lockfree", "bounded"}},
        {"thread.max_queue_size", "Maximum task queue size", false,
         "UNIFIED_THREAD_MAX_QUEUE_SIZE", {}},
 
        // Logger configuration
        {"logger.level", "Log level", true,
         "UNIFIED_LOGGER_LEVEL",
         {"trace", "debug", "info", "warn", "error", "critical", "off"}},
        {"logger.async", "Enable async logging", false,
         "UNIFIED_LOGGER_ASYNC", {}},
        {"logger.buffer_size", "Async buffer size", false,
         "UNIFIED_LOGGER_BUFFER_SIZE", {}},
        {"logger.file_path", "Log file path", true,
         "UNIFIED_LOGGER_FILE_PATH", {}},
 
        // Monitoring configuration
        {"monitoring.enabled", "Enable monitoring", false,
         "UNIFIED_MONITORING_ENABLED", {}},
        {"monitoring.metrics_interval", "Metrics collection interval (ms)", true,
         "UNIFIED_MONITORING_METRICS_INTERVAL_MS", {}},
        {"monitoring.tracing.enabled", "Enable distributed tracing", false,
         "UNIFIED_MONITORING_TRACING_ENABLED", {}},
        {"monitoring.tracing.sampling_rate", "Trace sampling rate", true,
         "UNIFIED_MONITORING_TRACING_SAMPLING_RATE", {}},
 
        // Database configuration
        {"database.backend", "Database backend type", false,
         "UNIFIED_DATABASE_BACKEND",
         {"postgresql", "mysql", "sqlite", "mongodb", "redis"}},
        {"database.connection_string", "Database connection string", false,
         "UNIFIED_DATABASE_CONNECTION_STRING", {}},
        {"database.pool.min_size", "Minimum pool size", false,
         "UNIFIED_DATABASE_POOL_MIN_SIZE", {}},
        {"database.pool.max_size", "Maximum pool size", false,
         "UNIFIED_DATABASE_POOL_MAX_SIZE", {}},
 
        // Network configuration
        {"network.tls.enabled", "Enable TLS", false,
         "UNIFIED_NETWORK_TLS_ENABLED", {}},
        {"network.tls.version", "TLS version", false,
         "UNIFIED_NETWORK_TLS_VERSION", {"1.2", "1.3"}},
        {"network.compression", "Compression algorithm", false,
         "UNIFIED_NETWORK_COMPRESSION", {"none", "lz4", "gzip", "deflate", "zstd"}},
        {"network.buffer_size", "I/O buffer size", false,
         "UNIFIED_NETWORK_BUFFER_SIZE", {}},
    };
}
 
inline bool is_hot_reloadable(const std::string& field_path) {
    static const std::vector<std::string> hot_reloadable_fields = {
        "logger.level",
        "logger.file_path",
        "monitoring.metrics_interval",
        "monitoring.tracing.sampling_rate",
    };
 
    for (const auto& field : hot_reloadable_fields) {
        if (field_path == field) {
            return true;
        }
    }
    return false;
}
 
}  // namespace kcenon::common::config