logger_builder.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 "thread_integration_detector.h"
#include "logger_config.h"
#include "strategies/config_strategy_interface.h"
#include "strategies/environment_strategy.h"
#include "strategies/performance_strategy.h"
#include "strategies/deployment_strategy.h"
#include "strategies/composite_strategy.h"
#include "logger.h"
#include "../backends/integration_backend.h"
#include "../backends/standalone_backend.h"
#include "../interfaces/log_writer_interface.h"
#include "../writers/batch_writer.h"
#include "../writers/console_writer.h"
#include "../filters/log_filter.h"
#include "../interfaces/log_formatter_interface.h"
#include "../routing/log_router.h"
#include "../analysis/realtime_log_analyzer.h"
#include "../sampling/log_sampler.h"
 
// Use common_system interfaces (Phase 2.2.4)
#include <kcenon/common/interfaces/monitoring_interface.h>
 
#include <memory>
#include <vector>
#include <algorithm>
#include <cstdlib>
 
namespace kcenon::logger {
 
class logger_builder {
public:
    logger_builder() : config_(logger_config::default_config()) {}
    
    logger_builder& with_config(const logger_config& config) {
        config_ = config;
        return *this;
    }
    
    logger_builder& with_async(bool async = true) {
        config_.async = async;
        // When disabling async, ensure batch_size is 1
        if (!async && config_.batch_size > 1) {
            config_.batch_size = 1;
        }
        return *this;
    }
    
    logger_builder& with_buffer_size(std::size_t size) {
        config_.buffer_size = size;
        return *this;
    }
    
    logger_builder& with_min_level(log_level level) {
        config_.min_level = level;
        return *this;
    }
 
    logger_builder& with_batch_size(std::size_t size) {
        config_.batch_size = size;
        return *this;
    }
    
    logger_builder& with_batch_writing(bool enable = true) {
        config_.enable_batch_writing = enable;
        return *this;
    }
    
    logger_builder& with_flush_interval(std::chrono::milliseconds interval) {
        config_.flush_interval = interval;
        return *this;
    }
    
    logger_builder& with_lock_free(bool enable = true) {
        config_.use_lock_free = enable;
        return *this;
    }
    
    logger_builder& with_metrics(bool enable = true) {
        config_.enable_metrics = enable;
        return *this;
    }
    
    logger_builder& with_crash_handler(bool enable = true) {
        config_.enable_crash_handler = enable;
        return *this;
    }
    
    logger_builder& with_structured_logging(bool enable = true) {
        config_.enable_structured_logging = enable;
        return *this;
    }
    
    logger_builder& with_overflow_policy(logger_config::overflow_policy policy) {
        config_.queue_overflow_policy = policy;
        return *this;
    }
    
    logger_builder& with_max_queue_size(std::size_t size) {
        config_.max_queue_size = size;
        return *this;
    }
    
    logger_builder& with_file_output(const std::string& directory,
                                    const std::string& prefix = "app",
                                    std::size_t max_size = 100 * 1024 * 1024,
                                    std::size_t max_count = 5) {
        config_.log_directory = directory;
        config_.log_file_prefix = prefix;
        config_.max_file_size = max_size;
        config_.max_file_count = max_count;
        return *this;
    }
    
    logger_builder& with_network_output(const std::string& host,
                                       uint16_t port,
                                       std::chrono::milliseconds timeout = std::chrono::milliseconds(5000)) {
        config_.remote_host = host;
        config_.remote_port = port;
        config_.network_timeout = timeout;
        return *this;
    }
    
    logger_builder& add_writer(const std::string& name, log_writer_ptr writer) {
        writers_.push_back({name, std::move(writer)});
        return *this;
    }
    
    logger_builder& add_filter(std::unique_ptr<log_filter_interface> filter) {
        if (filter) {
            filters_.push_back(std::move(filter));
        }
        return *this;
    }
 
    logger_builder& add_level_filter(log_level min_level) {
        filters_.push_back(std::make_unique<filters::level_filter>(min_level));
        return *this;
    }
 
    logger_builder& add_regex_filter(const std::string& pattern, bool include_matches = true) {
        filters_.push_back(std::make_unique<filters::regex_filter>(pattern, include_matches));
        return *this;
    }
 
    logger_builder& add_function_filter(std::function<bool(const log_entry&)> predicate) {
        filters_.push_back(std::make_unique<filters::function_filter>(std::move(predicate)));
        return *this;
    }
 
    // =========================================================================
    // Routing configuration
    // =========================================================================
 
    logger_builder& with_route(routing::route_config config) {
        routes_.push_back(std::move(config));
        return *this;
    }
 
    logger_builder& with_exclusive_routing(bool exclusive = true) {
        exclusive_routing_ = exclusive;
        return *this;
    }
 
    logger_builder& route_level(log_level level,
                                const std::vector<std::string>& writer_names,
                                bool stop_propagation = false) {
        routing::route_config config;
        config.writer_names = writer_names;
        config.filter = std::make_unique<filters::level_filter>(level);
        config.stop_propagation = stop_propagation;
        routes_.push_back(std::move(config));
        return *this;
    }
 
    logger_builder& route_pattern(const std::string& pattern,
                                  const std::vector<std::string>& writer_names,
                                  bool stop_propagation = false) {
        routing::route_config config;
        config.writer_names = writer_names;
        config.filter = std::make_unique<filters::regex_filter>(pattern, true);
        config.stop_propagation = stop_propagation;
        routes_.push_back(std::move(config));
        return *this;
    }
 
    logger_builder& with_formatter(std::unique_ptr<log_formatter_interface> formatter) {
        formatter_ = std::move(formatter);
        return *this;
    }
    
    logger_builder& use_template(const std::string& name) {
        // Use built-in logger_config templates
        if (name == "high_performance") {
            config_ = logger_config::high_performance();
        } else if (name == "low_latency") {
            config_ = logger_config::low_latency();
        } else if (name == "debug") {
            config_ = logger_config::debug_config();
        } else if (name == "production") {
            config_ = logger_config::production();
        } else {
            config_ = logger_config::default_config();
        }
        return *this;
    }
    
    logger_builder& apply_strategy(std::unique_ptr<config_strategy_interface> strategy) {
        if (strategy) {
            strategies_.push_back(std::move(strategy));
        }
        return *this;
    }
 
    logger_builder& for_environment(deployment_env env) {
        return apply_strategy(std::make_unique<deployment_strategy>(env));
    }
 
    logger_builder& with_performance_tuning(performance_level level) {
        return apply_strategy(std::make_unique<performance_strategy>(level));
    }
 
    logger_builder& auto_configure() {
        auto strategy = std::make_unique<environment_strategy>();
        if (strategy->is_applicable()) {
            apply_strategy(std::move(strategy));
        }
        return *this;
    }
 
    logger_builder& clear_strategies() {
        strategies_.clear();
        return *this;
    }
    
    
    logger_builder& detect_environment() {
        const char* env = std::getenv("LOG_ENV");
        const char* level = std::getenv("LOG_LEVEL");
 
        if (env) {
            std::string env_str(env);
            if (env_str == "production") {
                use_template("production");
            } else if (env_str == "debug" || env_str == "development") {
                use_template("debug");
            }
        }
 
        if (level) {
            std::string level_str(level);
            if (level_str == "trace") config_.min_level = log_level::trace;
            else if (level_str == "debug") config_.min_level = log_level::debug;
            else if (level_str == "info") config_.min_level = log_level::info;
            else if (level_str == "warn") config_.min_level = log_level::warning;
            else if (level_str == "error") config_.min_level = log_level::error;
            else if (level_str == "fatal") config_.min_level = log_level::critical;
        }
 
        return *this;
    }
 
    logger_builder& with_monitoring(std::shared_ptr<common::interfaces::IMonitor> monitor) {
        monitor_ = monitor;
        config_.enable_metrics = true;
        return *this;
    }
 
    logger_builder& with_health_check_interval(std::chrono::milliseconds interval) {
        health_check_interval_ = interval;
        return *this;
    }
    
    
    logger_builder& with_backend(std::unique_ptr<backends::integration_backend> backend) {
        backend_ = std::move(backend);
        return *this;
    }
 
    logger_builder& with_standalone_backend() {
        backend_ = std::make_unique<backends::standalone_backend>();
        return *this;
    }
 
    logger_builder& with_error_handler(std::function<void(const logger_error_code&)> handler) {
        error_handler_ = handler;
        return *this;
    }
 
    // =========================================================================
    // Real-time analysis configuration (requires LOGGER_WITH_ANALYSIS)
    // =========================================================================
 
#ifdef LOGGER_WITH_ANALYSIS
    logger_builder& with_realtime_analyzer(
        std::unique_ptr<analysis::realtime_log_analyzer> analyzer) {
        realtime_analyzer_ = std::move(analyzer);
        return *this;
    }
 
    logger_builder& with_realtime_analysis(
        const analysis::realtime_analysis_config& config,
        analysis::realtime_log_analyzer::anomaly_callback callback = nullptr) {
        realtime_analyzer_ = std::make_unique<analysis::realtime_log_analyzer>(config);
        if (callback) {
            realtime_analyzer_->set_anomaly_callback(std::move(callback));
        }
        return *this;
    }
 
    logger_builder& with_realtime_analysis(
        size_t error_threshold = 50,
        analysis::realtime_log_analyzer::anomaly_callback callback = nullptr) {
        realtime_analyzer_ = analysis::realtime_analyzer_factory::create_production(
            error_threshold, std::move(callback));
        return *this;
    }
#endif  // LOGGER_WITH_ANALYSIS
 
    logger_builder& with_default_pattern() {
        // Set a default format pattern
        config_.enable_timestamp = true;
        config_.enable_source_location = true;
        return *this;
    }
 
    // =========================================================================
    // Sampling configuration
    // =========================================================================
 
    logger_builder& with_sampler(std::unique_ptr<sampling::log_sampler> sampler) {
        sampler_ = std::move(sampler);
        return *this;
    }
 
    logger_builder& with_sampling(const sampling::sampling_config& config) {
        sampler_ = std::make_unique<sampling::log_sampler>(config);
        return *this;
    }
 
    // Legacy sampling methods (with_random_sampling, with_rate_limiting, with_adaptive_sampling)
    // removed. Use with_sampling(sampling_config::random_sampling(rate)),
    // with_sampling(sampling_config::rate_limited(max_per_second)),
    // with_sampling(sampling_config::adaptive(threshold, min_rate)) instead.
 
    result<std::unique_ptr<logger>> build() {
        // Apply all strategies in priority order (highest first)
        if (!strategies_.empty()) {
            // Sort strategies by priority (descending)
            std::sort(strategies_.begin(), strategies_.end(),
                [](const auto& a, const auto& b) {
                    return a->priority() > b->priority();
                });
 
            // Apply each applicable strategy
            for (const auto& strategy : strategies_) {
                if (strategy->is_applicable()) {
                    strategy->apply(config_);
                }
            }
        }
 
        // Validate configuration
        if (auto validation = config_.validate(); validation.is_err()) {
            return result<std::unique_ptr<logger>>{
                logger_error_code::invalid_configuration,
                "Configuration validation failed"};
        }
 
        // Validate writer count
        if (!writers_.empty() && writers_.size() > config_.max_writers) {
            return result<std::unique_ptr<logger>>{
                logger_error_code::invalid_configuration,
                "Number of writers exceeds max_writers configuration"};
        }
 
        // Auto-detect backend if not explicitly set
        // Users can provide thread_system_backend or other backends via with_backend()
        if (!backend_) {
            backend_ = std::make_unique<backends::standalone_backend>();
        }
 
        // Create logger with validated configuration
        auto logger_instance = std::make_unique<logger>(config_.async, config_.buffer_size, std::move(backend_));
 
        // Apply configuration settings
        logger_instance->set_level(config_.min_level);
        
        if (config_.enable_metrics) {
            logger_instance->enable_metrics_collection(true);
        }
        
        // Add writers (apply batch writing if enabled)
        for (auto& [name, writer] : writers_) {
            if (writer) {
                // Set color output if the writer supports it (console_writer)
                if (auto* console = dynamic_cast<console_writer*>(writer.get())) {
                    console->set_use_color(config_.enable_color_output);
                }
                
                // Wrap with batch writer if enabled and async mode
                if (config_.enable_batch_writing && config_.async) {
                    batch_writer::config batch_cfg;
                    batch_cfg.max_batch_size = config_.batch_size;
                    batch_cfg.flush_interval = config_.flush_interval;
                    
                    auto batch_wrapped = std::make_unique<batch_writer>(
                        std::move(writer), batch_cfg
                    );
                    logger_instance->add_writer(name, std::move(batch_wrapped));
                } else {
                    logger_instance->add_writer(name, std::move(writer));
                }
            }
        }
 
        // Apply filters if any were added
        if (!filters_.empty()) {
            // Create composite filter if multiple filters
            if (filters_.size() == 1) {
                logger_instance->set_filter(std::move(filters_[0]));
            } else {
                auto composite = std::make_unique<filters::composite_filter>(filters::composite_filter::logic_type::AND);
                for (auto& filter : filters_) {
                    composite->add_filter(std::move(filter));
                }
                logger_instance->set_filter(std::move(composite));
            }
        }
        filters_.clear();  // Clear after moving
 
        // Apply routing configuration
        if (!routes_.empty()) {
            auto& router = logger_instance->get_router();
            router.set_exclusive_routes(exclusive_routing_);
            for (auto& route : routes_) {
                router.add_route(std::move(route));
            }
        }
        routes_.clear();  // Clear after moving
 
        // Apply real-time analyzer if configured
#ifdef LOGGER_WITH_ANALYSIS
        if (realtime_analyzer_) {
            logger_instance->set_realtime_analyzer(std::move(realtime_analyzer_));
        }
#endif  // LOGGER_WITH_ANALYSIS
 
        // Apply sampler if configured
        if (sampler_) {
            logger_instance->set_sampler(std::move(sampler_));
        }
 
        // Start logger if async
        if (config_.async) {
            logger_instance->start();
        }
 
        // Store configuration in logger (if we add a config getter)
        built_config_ = config_;
 
        // Return logger instance (NRVO will be applied automatically)
        return logger_instance;
    }
    
    const logger_config& get_config() const {
        return config_;
    }
    
    common::VoidResult validate() const {
        return config_.validate();
    }
    
private:
    logger_config config_;
    std::vector<std::pair<std::string, log_writer_ptr>> writers_;
    std::vector<std::unique_ptr<log_filter_interface>> filters_;
    std::vector<routing::route_config> routes_;  // Routing configurations
    bool exclusive_routing_ = false;  // Exclusive routing mode flag
    std::unique_ptr<log_formatter_interface> formatter_;
    std::unique_ptr<backends::integration_backend> backend_;  // Integration backend (Phase 3.2)
    std::vector<std::unique_ptr<config_strategy_interface>> strategies_;  // Configuration strategies
    mutable logger_config built_config_;  // Store last built configuration
    std::shared_ptr<common::interfaces::IMonitor> monitor_;  // Phase 2.2.4
    std::chrono::milliseconds health_check_interval_{1000};
    std::function<void(const logger_error_code&)> error_handler_;
#ifdef LOGGER_WITH_ANALYSIS
    std::unique_ptr<analysis::realtime_log_analyzer> realtime_analyzer_;  // Real-time analyzer
#endif  // LOGGER_WITH_ANALYSIS
    std::unique_ptr<sampling::log_sampler> sampler_;  // Log sampler for volume reduction
};
 
} // namespace kcenon::logger