configuration.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 <cstddef>
#include <cstdint>
#include <string>
 
namespace database
{
namespace integrated
{
 
enum class db_log_level
{
    trace,    
    debug,    
    info,     
    warning,  
    error,    
    critical, 
    fatal     
};
 
enum class backend_type
{
    postgres, 
    sqlite,   
    mongodb,  
    redis     
};
 
enum class thread_pool_type
{
    standard, 
    typed     
};
 
struct pool_config
{
    std::string pool_name{ "default_pool" };
 
    std::size_t min_connections{ 2 };
 
    std::size_t max_connections{ 10 };
 
    std::chrono::seconds connection_timeout{ 30 };
 
    std::chrono::seconds idle_timeout{ 300 }; // 5 minutes
 
    bool enable_health_checks{ true };
 
    std::chrono::seconds health_check_interval{ 60 };
 
    bool enable_priority_queue{ false };
};
 
struct db_thread_config
{
    std::string pool_name{ "db_thread_pool" };
 
    std::size_t thread_count{ 0 };
 
    std::size_t max_queue_size{ 1000 };
 
    bool enable_priority_scheduling{ false };
 
    thread_pool_type pool_type{ thread_pool_type::standard };
};
 
struct db_logger_config
{
    bool enable_query_logging{ false };
 
    bool enable_connection_logging{ true };
 
    bool log_slow_queries{ true };
 
    std::chrono::milliseconds slow_query_threshold{ 1000 }; // 1 second
 
    db_log_level min_log_level{ db_log_level::info };
 
    bool enable_file_logging{ false };
 
    std::string log_directory{ "./logs" };
 
    std::size_t log_rotation_size{ 10 * 1024 * 1024 }; // 10 MB
 
    std::size_t log_rotation_count{ 5 };
};
 
struct db_monitoring_config
{
    bool enable_metrics{ true };
 
    bool enable_profiling{ false };
 
    bool enable_health_checks{ true };
 
    std::chrono::seconds metrics_interval{ 60 };
 
    double connection_usage_warning_threshold{ 0.8 }; // 80%
 
    std::chrono::milliseconds query_latency_warning{ 500 };
 
    bool enable_prometheus_export{ false };
 
    std::string prometheus_endpoint{ "/metrics" };
 
    std::uint16_t prometheus_port{ 9090 };
};
 
struct database_config
{
    backend_type type{ backend_type::postgres };
 
    std::string connection_string{ "host=localhost port=5432 dbname=postgres" };
 
    bool enable_ssl{ false };
 
    std::string ssl_cert_path{};
 
    std::string ssl_key_path{};
 
    bool enable_prepared_statements{ true };
 
    bool enable_query_cache{ false };
 
    std::size_t query_cache_size{ 100 * 1024 * 1024 }; // 100 MB
 
    std::string username{};
 
    std::string password{};
};
 
struct unified_db_config
{
    database_config database;
 
    pool_config connection_pool;
 
    db_thread_config thread;
 
    db_logger_config logger;
 
    db_monitoring_config monitoring;
 
    // Integration flags (compile-time configurable via CMake)
    bool enable_common_system_integration{ true };
 
    bool enable_thread_system_integration{ true };
 
    bool enable_monitoring_system_integration{ true };
 
    // Builder pattern methods for fluent API
 
    unified_db_config& set_backend(backend_type type, const std::string& connection_str)
    {
        database.type = type;
        database.connection_string = connection_str;
        return *this;
    }
 
    unified_db_config& set_credentials(const std::string& user, const std::string& pass)
    {
        database.username = user;
        database.password = pass;
        return *this;
    }
 
    unified_db_config& set_pool_size(std::size_t min, std::size_t max)
    {
        connection_pool.min_connections = min;
        connection_pool.max_connections = max;
        return *this;
    }
 
    unified_db_config& set_pool_name(const std::string& name)
    {
        connection_pool.pool_name = name;
        return *this;
    }
 
    unified_db_config& set_log_level(db_log_level level)
    {
        logger.min_log_level = level;
        return *this;
    }
 
    unified_db_config& enable_query_logging(bool enable = true)
    {
        logger.enable_query_logging = enable;
        return *this;
    }
 
    unified_db_config& enable_slow_query_logging(
        bool enable = true, std::chrono::milliseconds threshold = std::chrono::milliseconds(1000))
    {
        logger.log_slow_queries = enable;
        logger.slow_query_threshold = threshold;
        return *this;
    }
 
    unified_db_config& enable_file_logging(bool enable = true, const std::string& directory = "./logs")
    {
        logger.enable_file_logging = enable;
        logger.log_directory = directory;
        return *this;
    }
 
    unified_db_config& enable_monitoring(bool enable = true)
    {
        monitoring.enable_metrics = enable;
        monitoring.enable_health_checks = enable;
        return *this;
    }
 
    unified_db_config& enable_prometheus(
        bool enable = true, std::uint16_t port = 9090, const std::string& endpoint = "/metrics")
    {
        monitoring.enable_prometheus_export = enable;
        monitoring.prometheus_port = port;
        monitoring.prometheus_endpoint = endpoint;
        return *this;
    }
 
    unified_db_config& set_thread_count(std::size_t count)
    {
        thread.thread_count = count;
        return *this;
    }
 
    unified_db_config& enable_priority_scheduling(bool enable = true)
    {
        thread.enable_priority_scheduling = enable;
        connection_pool.enable_priority_queue = enable;
        if (enable)
        {
            thread.pool_type = thread_pool_type::typed;
        }
        return *this;
    }
 
    unified_db_config& enable_ssl(bool enable = true, const std::string& cert_path = "",
        const std::string& key_path = "")
    {
        database.enable_ssl = enable;
        database.ssl_cert_path = cert_path;
        database.ssl_key_path = key_path;
        return *this;
    }
 
    unified_db_config& set_timeouts(std::chrono::seconds acquisition, std::chrono::seconds idle)
    {
        connection_pool.connection_timeout = acquisition;
        connection_pool.idle_timeout = idle;
        return *this;
    }
};
 
} // namespace integrated
} // namespace database