Builder pattern for logger construction with validation. More...

#include <logger_builder.h>

Collaboration diagram for kcenon::logger::logger_builder:

Public Member Functions
	logger_builder ()

logger_builder &	with_config (const logger_config &config)

logger_builder &	with_async (bool async=true)

logger_builder &	with_buffer_size (std::size_t size)
	Set buffer size.

logger_builder &	with_min_level (log_level level)

logger_builder &	with_batch_size (std::size_t size)
	Set batch size for processing.

logger_builder &	with_batch_writing (bool enable=true)
	Enable batch writing for writers.

logger_builder &	with_flush_interval (std::chrono::milliseconds interval)
	Set flush interval.

logger_builder &	with_lock_free (bool enable=true)
	Enable lock-free queue.

logger_builder &	with_metrics (bool enable=true)
	Enable metrics collection.

logger_builder &	with_crash_handler (bool enable=true)
	Enable crash handler.

logger_builder &	with_structured_logging (bool enable=true)
	Enable structured logging.

logger_builder &	with_overflow_policy (logger_config::overflow_policy policy)
	Set queue overflow policy.

logger_builder &	with_max_queue_size (std::size_t size)
	Set max queue size.

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)
	Configure file output.

logger_builder &	with_network_output (const std::string &host, uint16_t port, std::chrono::milliseconds timeout=std::chrono::milliseconds(5000))
	Configure network output.

logger_builder &	add_writer (const std::string &name, log_writer_ptr writer)
	Add a writer to the logger.

logger_builder &	add_filter (std::unique_ptr< log_filter_interface > filter)

logger_builder &	add_level_filter (log_level min_level)
	Add a level filter (convenience method)

logger_builder &	add_regex_filter (const std::string &pattern, bool include_matches=true)
	Add a regex filter (convenience method)

logger_builder &	add_function_filter (std::function< bool(const log_entry &)> predicate)
	Add a function-based filter (convenience method)

logger_builder &	with_route (routing::route_config config)

logger_builder &	with_exclusive_routing (bool exclusive=true)
	Set exclusive routing mode.

logger_builder &	route_level (log_level level, const std::vector< std::string > &writer_names, bool stop_propagation=false)

logger_builder &	route_pattern (const std::string &pattern, const std::vector< std::string > &writer_names, bool stop_propagation=false)

logger_builder &	with_formatter (std::unique_ptr< log_formatter_interface > formatter)
	Set formatter for the logger.

logger_builder &	use_template (const std::string &name)

logger_builder &	apply_strategy (std::unique_ptr< config_strategy_interface > strategy)
	Apply a configuration strategy.

logger_builder &	for_environment (deployment_env env)
	Configure for a specific deployment environment.

logger_builder &	with_performance_tuning (performance_level level)
	Apply performance tuning.

logger_builder &	auto_configure ()
	Auto-configure from environment variables.

logger_builder &	clear_strategies ()
	Clear all registered strategies.

logger_builder &	detect_environment ()
	Detect environment from environment variables.

logger_builder &	with_monitoring (std::shared_ptr< common::interfaces::IMonitor > monitor)
	Set monitoring interface (Phase 2.2.4)

logger_builder &	with_health_check_interval (std::chrono::milliseconds interval)
	Set health check interval.

logger_builder &	with_backend (std::unique_ptr< backends::integration_backend > backend)
	Set integration backend explicitly.

logger_builder &	with_standalone_backend ()
	Use standalone backend explicitly.

logger_builder &	with_error_handler (std::function< void(const logger_error_code &)> handler)
	Set error handler.

logger_builder &	with_default_pattern ()
	Use default pattern for logging.

logger_builder &	with_sampler (std::unique_ptr< sampling::log_sampler > sampler)

logger_builder &	with_sampling (const sampling::sampling_config &config)

result< std::unique_ptr< logger > >	build ()

const logger_config &	get_config () const
	Get the current configuration (for inspection)

common::VoidResult	validate () const
	Validate current configuration without building.

Private Attributes
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_

bool	exclusive_routing_ = false

std::unique_ptr< log_formatter_interface >	formatter_

std::unique_ptr< backends::integration_backend >	backend_

std::vector< std::unique_ptr< config_strategy_interface > >	strategies_

logger_config	built_config_

std::shared_ptr< common::interfaces::IMonitor >	monitor_

std::chrono::milliseconds	health_check_interval_ {1000}

std::function< void(const logger_error_code &)>	error_handler_

std::unique_ptr< sampling::log_sampler >	sampler_

Detailed Description

Builder pattern for logger construction with validation.

The logger_builder class provides a fluent interface for constructing logger instances with complex configurations. It ensures configuration validity, applies optimization strategies, and handles the complexity of logger initialization.

Key features:

Fluent interface for intuitive configuration
Automatic validation of configuration parameters
Support for configuration templates and strategies
Environment-based auto-configuration
Integration with dependency injection containers
Performance tuning presets

Note: All builder methods return a reference to the builder for method chaining.

Warning: The build() method consumes writers and filters. After calling build(), the builder should not be reused without adding new writers.

Since: 1.0.0

Examples: critical_logging_example.cpp, custom_writer_example.cpp, di_pattern_example.cpp, and monitoring_integration_example.cpp.

Definition at line 116 of file logger_builder.h.

Constructor & Destructor Documentation

◆ logger_builder()

kcenon::logger::logger_builder::logger_builder ( )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 118 of file logger_builder.h.

118: config_(logger_config::default_config()) {}

kcenon::logger::logger_builder::config_

logger_config config_

Definition logger_builder.h:1077

kcenon::logger::logger_config::default_config

static logger_config default_config()

Create a default configuration.

Definition logger_config.h:222

Member Function Documentation

◆ add_filter()

logger_builder & kcenon::logger::logger_builder::add_filter ( std::unique_ptr< log_filter_interface > filter )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 375 of file logger_builder.h.

                                                                           {
        if (filter) {
            filters_.push_back(std::move(filter));
        }
        return *this;
    }

References filters_.

◆ add_function_filter()

logger_builder & kcenon::logger::logger_builder::add_function_filter ( std::function< bool(const log_entry &)> predicate )

inline

Add a function-based filter (convenience method)

Parameters

predicate Function that returns true for entries that should pass

Returns: Reference to builder for chaining

Since: 2.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 414 of file logger_builder.h.

                                                                                       {
        filters_.push_back(std::make_unique<filters::function_filter>(std::move(predicate)));
        return *this;
    }

References filters_.

◆ add_level_filter()

logger_builder & kcenon::logger::logger_builder::add_level_filter ( log_level min_level )

inline

Add a level filter (convenience method)

Parameters

min_level Minimum log level to pass through

Returns: Reference to builder for chaining

Since: 2.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 389 of file logger_builder.h.

                                                          {
        filters_.push_back(std::make_unique<filters::level_filter>(min_level));
        return *this;
    }

References filters_.

◆ add_regex_filter()

logger_builder & kcenon::logger::logger_builder::add_regex_filter	(	const std::string &	pattern,
		bool	include_matches = true )

inline

Add a regex filter (convenience method)

Parameters

pattern	Regex pattern to match against log messages
include_matches	If true, only matching messages pass; if false, non-matching pass

Returns: Reference to builder for chaining

Since: 2.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 402 of file logger_builder.h.

                                                                                            {
        filters_.push_back(std::make_unique<filters::regex_filter>(pattern, include_matches));
        return *this;
    }

References filters_.

◆ add_writer()

logger_builder & kcenon::logger::logger_builder::add_writer	(	const std::string &	name,
		log_writer_ptr	writer )

inline

Add a writer to the logger.

Parameters

name	Writer name
writer	Writer instance

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h, critical_logging_example.cpp, and custom_writer_example.cpp.

Definition at line 352 of file logger_builder.h.

                                                                             {
        writers_.push_back({name, std::move(writer)});
        return *this;
    }

References writers_.

Referenced by example_production_setup(), and main().

Here is the caller graph for this function:

◆ apply_strategy()

logger_builder & kcenon::logger::logger_builder::apply_strategy ( std::unique_ptr< config_strategy_interface > strategy )

inline

Apply a configuration strategy.

Parameters

strategy Strategy to apply during build

Returns: Reference to builder for chaining

Strategies are applied in priority order during build(). Higher priority strategies are applied first.

Since: 2.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 586 of file logger_builder.h.

                                                                                      {
        if (strategy) {
            strategies_.push_back(std::move(strategy));
        }
        return *this;
    }

References strategies_.

Referenced by auto_configure(), for_environment(), and with_performance_tuning().

Here is the caller graph for this function:

◆ auto_configure()

logger_builder & kcenon::logger::logger_builder::auto_configure ( )

inline

Auto-configure from environment variables.

Returns: Reference to builder for chaining

Reads LOG_* environment variables and applies them:

LOG_LEVEL, LOG_ASYNC, LOG_BUFFER_SIZE, LOG_BATCH_SIZE
LOG_FLUSH_INTERVAL, LOG_COLOR, LOG_METRICS

Since: 2.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 637 of file logger_builder.h.

                                     {
        auto strategy = std::make_unique<environment_strategy>();
        if (strategy->is_applicable()) {
            apply_strategy(std::move(strategy));
        }
        return *this;
    }

References apply_strategy().

Here is the call graph for this function:

◆ build()

result< std::unique_ptr< logger > > kcenon::logger::logger_builder::build ( )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h, custom_writer_example.cpp, di_pattern_example.cpp, and monitoring_integration_example.cpp.

Definition at line 940 of file logger_builder.h.

                                          {
        // 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;
    }

Referenced by example_1_basic_di_pattern(), example_1_basic_integration(), example_2_multiple_loggers(), example_2_optional_monitor(), example_3_imonitorable_interface(), example_3_runtime_monitor_injection(), example_4_monitor_swapping(), example_4_monitoring_system_simulation(), example_5_interface_based_usage(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_strategies()

logger_builder & kcenon::logger::logger_builder::clear_strategies ( )

inline

Clear all registered strategies.

Returns: Reference to builder for chaining

Since: 2.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 651 of file logger_builder.h.

                                       {
        strategies_.clear();
        return *this;
    }

References strategies_.

◆ detect_environment()

logger_builder & kcenon::logger::logger_builder::detect_environment ( )

inline

Detect environment from environment variables.

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 661 of file logger_builder.h.

                                         {
        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;
    }

References config_, kcenon::logger::logger_config::min_level, and use_template().

Here is the call graph for this function:

◆ for_environment()

logger_builder & kcenon::logger::logger_builder::for_environment ( deployment_env env )

inline

Configure for a specific deployment environment.

Parameters

env	Deployment environment type

Returns: Reference to builder for chaining

Applies pre-configured settings optimized for the environment:

development: Verbose, colored, synchronous
staging: JSON, file + console, rotation
production: Optimized, warning+, crash protection
testing: Memory buffer, synchronous

Since: 2.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 606 of file logger_builder.h.

                                                        {
        return apply_strategy(std::make_unique<deployment_strategy>(env));
    }

References apply_strategy().

Here is the call graph for this function:

◆ get_config()

const logger_config & kcenon::logger::logger_builder::get_config ( ) const

inline

Get the current configuration (for inspection)

Returns: Current configuration

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1064 of file logger_builder.h.

                                            {
        return config_;
    }

References config_.

◆ route_level()

logger_builder & kcenon::logger::logger_builder::route_level	(	log_level	level,
		const std::vector< std::string > &	writer_names,
		bool	stop_propagation = false )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 484 of file logger_builder.h.

                                                               {
        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;
    }

References kcenon::logger::routing::route_config::filter, routes_, kcenon::logger::routing::route_config::stop_propagation, and kcenon::logger::routing::route_config::writer_names.

◆ route_pattern()

logger_builder & kcenon::logger::logger_builder::route_pattern	(	const std::string &	pattern,
		const std::vector< std::string > &	writer_names,
		bool	stop_propagation = false )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 513 of file logger_builder.h.

                                                                 {
        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;
    }

References kcenon::logger::routing::route_config::filter, routes_, kcenon::logger::routing::route_config::stop_propagation, and kcenon::logger::routing::route_config::writer_names.

◆ use_template()

logger_builder & kcenon::logger::logger_builder::use_template ( const std::string & name )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 560 of file logger_builder.h.

                                                        {
        // 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;
    }

References config_, kcenon::logger::logger_config::debug_config(), kcenon::logger::logger_config::default_config(), kcenon::logger::logger_config::high_performance(), kcenon::logger::logger_config::low_latency(), and kcenon::logger::logger_config::production().

Referenced by detect_environment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate()

common::VoidResult kcenon::logger::logger_builder::validate ( ) const

inline

Validate current configuration without building.

Returns: Validation result

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1072 of file logger_builder.h.

                                      {
        return config_.validate();
    }

References config_, and kcenon::logger::logger_config::validate().

Here is the call graph for this function:

◆ with_async()

logger_builder & kcenon::logger::logger_builder::with_async ( bool async = true )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h, critical_logging_example.cpp, di_pattern_example.cpp, and monitoring_integration_example.cpp.

Definition at line 166 of file logger_builder.h.

                                                  {
        config_.async = async;
        // When disabling async, ensure batch_size is 1
        if (!async && config_.batch_size > 1) {
            config_.batch_size = 1;
        }
        return *this;
    }

References kcenon::logger::logger_config::async, kcenon::logger::logger_config::batch_size, and config_.

Referenced by example_1_basic_di_pattern(), example_1_basic_integration(), example_2_multiple_loggers(), example_2_optional_monitor(), example_3_imonitorable_interface(), example_3_runtime_monitor_injection(), example_4_monitor_swapping(), example_4_monitoring_system_simulation(), example_5_interface_based_usage(), and example_production_setup().

Here is the caller graph for this function:

◆ with_backend()

logger_builder & kcenon::logger::logger_builder::with_backend ( std::unique_ptr< backends::integration_backend > backend )

inline

Set integration backend explicitly.

Parameters

backend Custom integration backend

Returns: Reference to builder for chaining

Allows setting a custom integration backend instead of using the auto-detected one. Useful for testing or custom integration scenarios.

Since: 1.2.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 719 of file logger_builder.h.

                                                                                     {
        backend_ = std::move(backend);
        return *this;
    }

References backend_.

◆ with_batch_size()

logger_builder & kcenon::logger::logger_builder::with_batch_size ( std::size_t size )

inline

Set batch size for processing.

Parameters

size	Batch size

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 226 of file logger_builder.h.

                                                    {
        config_.batch_size = size;
        return *this;
    }

References kcenon::logger::logger_config::batch_size, config_, and kcenon::logger::size.

◆ with_batch_writing()

logger_builder & kcenon::logger::logger_builder::with_batch_writing ( bool enable = true )

inline

Enable batch writing for writers.

Parameters

enable Enable/disable batch writing

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 236 of file logger_builder.h.

                                                           {
        config_.enable_batch_writing = enable;
        return *this;
    }

References config_, and kcenon::logger::logger_config::enable_batch_writing.

◆ with_buffer_size()

logger_builder & kcenon::logger::logger_builder::with_buffer_size ( std::size_t size )

inline

Set buffer size.

Parameters

size	Buffer size in bytes

Returns: Reference to builder for chaining

Configures the internal buffer size for log message queuing. Larger buffers can improve throughput but increase memory usage.

Note

Recommended sizes:

Small applications: 4096-8192 bytes
Medium applications: 16384-32768 bytes
High-throughput applications: 65536+ bytes

Warning: Very large buffers may cause memory pressure in constrained environments.

Since: 1.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h, and critical_logging_example.cpp.

Definition at line 192 of file logger_builder.h.

                                                     {
        config_.buffer_size = size;
        return *this;
    }

References kcenon::logger::logger_config::buffer_size, config_, and kcenon::logger::size.

Referenced by example_production_setup().

Here is the caller graph for this function:

◆ with_config()

logger_builder & kcenon::logger::logger_builder::with_config ( const logger_config & config )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 139 of file logger_builder.h.

                                                             {
        config_ = config;
        return *this;
    }

References config_.

◆ with_crash_handler()

logger_builder & kcenon::logger::logger_builder::with_crash_handler ( bool enable = true )

inline

Enable crash handler.

Parameters

enable Enable/disable crash handler

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 276 of file logger_builder.h.

                                                           {
        config_.enable_crash_handler = enable;
        return *this;
    }

References config_, and kcenon::logger::logger_config::enable_crash_handler.

◆ with_default_pattern()

logger_builder & kcenon::logger::logger_builder::with_default_pattern ( )

inline

Use default pattern for logging.

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 844 of file logger_builder.h.

                                           {
        // Set a default format pattern
        config_.enable_timestamp = true;
        config_.enable_source_location = true;
        return *this;
    }

References config_, kcenon::logger::logger_config::enable_source_location, and kcenon::logger::logger_config::enable_timestamp.

◆ with_error_handler()

logger_builder & kcenon::logger::logger_builder::with_error_handler ( std::function< void(const logger_error_code &)> handler )

inline

Set error handler.

Parameters

handler Error handler function

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 743 of file logger_builder.h.

                                                                                            {
        error_handler_ = handler;
        return *this;
    }

References error_handler_.

◆ with_exclusive_routing()

logger_builder & kcenon::logger::logger_builder::with_exclusive_routing ( bool exclusive = true )

inline

Set exclusive routing mode.

Parameters

exclusive If true, only matched routes receive logs; otherwise all writers receive

Returns: Reference to builder for chaining

In exclusive mode, only writers matched by routing rules receive log messages. In non-exclusive mode (default), all writers receive messages regardless of routing.

Since: 2.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 461 of file logger_builder.h.

                                                                  {
        exclusive_routing_ = exclusive;
        return *this;
    }

References exclusive_routing_.

◆ with_file_output()

logger_builder & kcenon::logger::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 )

inline

Configure file output.

Parameters

directory	Log directory
prefix	File prefix
max_size	Maximum file size
max_count	Maximum file count for rotation

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 319 of file logger_builder.h.

                                                             {
        config_.log_directory = directory;
        config_.log_file_prefix = prefix;
        config_.max_file_size = max_size;
        config_.max_file_count = max_count;
        return *this;
    }

References config_, kcenon::logger::logger_config::log_directory, kcenon::logger::logger_config::log_file_prefix, kcenon::logger::logger_config::max_file_count, and kcenon::logger::logger_config::max_file_size.

◆ with_flush_interval()

logger_builder & kcenon::logger::logger_builder::with_flush_interval ( std::chrono::milliseconds interval )

inline

Set flush interval.

Parameters

interval Flush interval

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 246 of file logger_builder.h.

                                                                        {
        config_.flush_interval = interval;
        return *this;
    }

References config_, and kcenon::logger::logger_config::flush_interval.

◆ with_formatter()

logger_builder & kcenon::logger::logger_builder::with_formatter ( std::unique_ptr< log_formatter_interface > formatter )

inline

Set formatter for the logger.

Parameters

formatter Formatter instance

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 529 of file logger_builder.h.

                                                                                     {
        formatter_ = std::move(formatter);
        return *this;
    }

References formatter_.

◆ with_health_check_interval()

logger_builder & kcenon::logger::logger_builder::with_health_check_interval ( std::chrono::milliseconds interval )

inline

Set health check interval.

Parameters

interval Health check interval

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 703 of file logger_builder.h.

                                                                               {
        health_check_interval_ = interval;
        return *this;
    }

References health_check_interval_.

◆ with_lock_free()

logger_builder & kcenon::logger::logger_builder::with_lock_free ( bool enable = true )

inline

Enable lock-free queue.

Parameters

enable Enable/disable lock-free mode

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 256 of file logger_builder.h.

                                                       {
        config_.use_lock_free = enable;
        return *this;
    }

References config_, and kcenon::logger::logger_config::use_lock_free.

◆ with_max_queue_size()

logger_builder & kcenon::logger::logger_builder::with_max_queue_size ( std::size_t size )

inline

Set max queue size.

Parameters

size	Maximum queue size

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 306 of file logger_builder.h.

                                                        {
        config_.max_queue_size = size;
        return *this;
    }

References config_, kcenon::logger::logger_config::max_queue_size, and kcenon::logger::size.

◆ with_metrics()

logger_builder & kcenon::logger::logger_builder::with_metrics ( bool enable = true )

inline

Enable metrics collection.

Parameters

enable Enable/disable metrics

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 266 of file logger_builder.h.

                                                     {
        config_.enable_metrics = enable;
        return *this;
    }

References config_, and kcenon::logger::logger_config::enable_metrics.

◆ with_min_level()

logger_builder & kcenon::logger::logger_builder::with_min_level ( log_level level )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h, critical_logging_example.cpp, custom_writer_example.cpp, and di_pattern_example.cpp.

Definition at line 216 of file logger_builder.h.

                                                    {
        config_.min_level = level;
        return *this;
    }

References config_, and kcenon::logger::logger_config::min_level.

Referenced by example_1_basic_di_pattern(), example_2_optional_monitor(), example_production_setup(), and main().

Here is the caller graph for this function:

◆ with_monitoring()

logger_builder & kcenon::logger::logger_builder::with_monitoring ( std::shared_ptr< common::interfaces::IMonitor > monitor )

inline

Set monitoring interface (Phase 2.2.4)

Parameters

monitor IMonitor implementation from common_system

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h, di_pattern_example.cpp, and monitoring_integration_example.cpp.

Definition at line 692 of file logger_builder.h.

                                                                                     {
        monitor_ = monitor;
        config_.enable_metrics = true;
        return *this;
    }

References config_, kcenon::logger::logger_config::enable_metrics, and monitor_.

Referenced by example_1_basic_di_pattern(), example_1_basic_integration(), example_2_multiple_loggers(), example_3_imonitorable_interface(), example_4_monitoring_system_simulation(), and example_5_interface_based_usage().

Here is the caller graph for this function:

◆ with_network_output()

logger_builder & kcenon::logger::logger_builder::with_network_output	(	const std::string &	host,
		uint16_t	port,
		std::chrono::milliseconds	timeout = std::chrono::milliseconds(5000) )

inline

Configure network output.

Parameters

host	Remote host
port	Remote port
timeout	Connection timeout

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 337 of file logger_builder.h.

                                                                                                    {
        config_.remote_host = host;
        config_.remote_port = port;
        config_.network_timeout = timeout;
        return *this;
    }

References config_, kcenon::logger::logger_config::network_timeout, kcenon::logger::logger_config::remote_host, and kcenon::logger::logger_config::remote_port.

◆ with_overflow_policy()

logger_builder & kcenon::logger::logger_builder::with_overflow_policy ( logger_config::overflow_policy policy )

inline

Set queue overflow policy.

Parameters

policy Overflow policy to use

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 296 of file logger_builder.h.

                                                                              {
        config_.queue_overflow_policy = policy;
        return *this;
    }

References config_, and kcenon::logger::logger_config::queue_overflow_policy.

◆ with_performance_tuning()

logger_builder & kcenon::logger::logger_builder::with_performance_tuning ( performance_level level )

inline

Apply performance tuning.

Parameters

level Performance tuning level

Returns: Reference to builder for chaining

Applies performance-optimized settings:

low_latency: Small buffers, immediate flush
balanced: Default balanced settings
high_throughput: Large buffers, batch processing
minimal_overhead: Reduced features, lower CPU usage

Since: 2.0.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 623 of file logger_builder.h.

                                                                     {
        return apply_strategy(std::make_unique<performance_strategy>(level));
    }

References apply_strategy().

Here is the call graph for this function:

◆ with_route()

logger_builder & kcenon::logger::logger_builder::with_route ( routing::route_config config )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 446 of file logger_builder.h.

                                                           {
        routes_.push_back(std::move(config));
        return *this;
    }

References routes_.

◆ with_sampler()

logger_builder & kcenon::logger::logger_builder::with_sampler ( std::unique_ptr< sampling::log_sampler > sampler )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 875 of file logger_builder.h.

                                                                             {
        sampler_ = std::move(sampler);
        return *this;
    }

References sampler_.

◆ with_sampling()

logger_builder & kcenon::logger::logger_builder::with_sampling ( const sampling::sampling_config & config )

inline

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 898 of file logger_builder.h.

                                                                         {
        sampler_ = std::make_unique<sampling::log_sampler>(config);
        return *this;
    }

References sampler_.

◆ with_standalone_backend()

logger_builder & kcenon::logger::logger_builder::with_standalone_backend ( )

inline

Use standalone backend explicitly.

Returns: Reference to builder for chaining

Explicitly selects the standalone integration backend. This is the default backend when no external integration is required.

Since: 1.2.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 733 of file logger_builder.h.

                                              {
        backend_ = std::make_unique<backends::standalone_backend>();
        return *this;
    }

References backend_.

◆ with_structured_logging()

logger_builder & kcenon::logger::logger_builder::with_structured_logging ( bool enable = true )

inline

Enable structured logging.

Parameters

enable Enable/disable structured logging

Returns: Reference to builder for chaining

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 286 of file logger_builder.h.

                                                                {
        config_.enable_structured_logging = enable;
        return *this;
    }

References config_, and kcenon::logger::logger_config::enable_structured_logging.

Member Data Documentation

◆ backend_

std::unique_ptr<backends::integration_backend> kcenon::logger::logger_builder::backend_

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1083 of file logger_builder.h.

Referenced by build(), with_backend(), and with_standalone_backend().

◆ built_config_

logger_config kcenon::logger::logger_builder::built_config_

mutableprivate

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1085 of file logger_builder.h.

Referenced by build().

◆ config_

logger_config kcenon::logger::logger_builder::config_

private

◆ error_handler_

std::function<void(const logger_error_code&)> kcenon::logger::logger_builder::error_handler_

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1088 of file logger_builder.h.

Referenced by with_error_handler().

◆ exclusive_routing_

bool kcenon::logger::logger_builder::exclusive_routing_ = false

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1081 of file logger_builder.h.

Referenced by build(), and with_exclusive_routing().

◆ filters_

std::vector<std::unique_ptr<log_filter_interface> > kcenon::logger::logger_builder::filters_

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1079 of file logger_builder.h.

Referenced by add_filter(), add_function_filter(), add_level_filter(), add_regex_filter(), and build().

◆ formatter_

std::unique_ptr<log_formatter_interface> kcenon::logger::logger_builder::formatter_

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1082 of file logger_builder.h.

Referenced by with_formatter().

◆ health_check_interval_

std::chrono::milliseconds kcenon::logger::logger_builder::health_check_interval_ {1000}

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1087 of file logger_builder.h.

1087{1000};

Referenced by with_health_check_interval().

◆ monitor_

std::shared_ptr<common::interfaces::IMonitor> kcenon::logger::logger_builder::monitor_

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1086 of file logger_builder.h.

Referenced by with_monitoring().

◆ routes_

std::vector<routing::route_config> kcenon::logger::logger_builder::routes_

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1080 of file logger_builder.h.

Referenced by build(), route_level(), route_pattern(), and with_route().

◆ sampler_

std::unique_ptr<sampling::log_sampler> kcenon::logger::logger_builder::sampler_

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1092 of file logger_builder.h.

Referenced by build(), with_sampler(), and with_sampling().

◆ strategies_

std::vector<std::unique_ptr<config_strategy_interface> > kcenon::logger::logger_builder::strategies_

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1084 of file logger_builder.h.

Referenced by apply_strategy(), build(), and clear_strategies().

◆ writers_

std::vector<std::pair<std::string, log_writer_ptr> > kcenon::logger::logger_builder::writers_

private

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/core/logger_builder.h.

Definition at line 1078 of file logger_builder.h.

Referenced by add_writer(), and build().

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

include/kcenon/logger/core/logger_builder.h

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ logger_builder()

Member Function Documentation

◆ add_filter()

◆ add_function_filter()

◆ add_level_filter()

◆ add_regex_filter()

◆ add_writer()

◆ apply_strategy()

◆ auto_configure()

◆ build()

◆ clear_strategies()

◆ detect_environment()

◆ for_environment()

◆ get_config()

◆ route_level()

◆ route_pattern()

◆ use_template()

◆ validate()

◆ with_async()

◆ with_backend()

◆ with_batch_size()

◆ with_batch_writing()

◆ with_buffer_size()

◆ with_config()

◆ with_crash_handler()

◆ with_default_pattern()

◆ with_error_handler()

◆ with_exclusive_routing()

◆ with_file_output()

◆ with_flush_interval()

◆ with_formatter()

◆ with_health_check_interval()

◆ with_lock_free()

◆ with_max_queue_size()

◆ with_metrics()

◆ with_min_level()

◆ with_monitoring()

◆ with_network_output()

◆ with_overflow_policy()

◆ with_performance_tuning()

◆ with_route()

◆ with_sampler()

◆ with_sampling()

◆ with_standalone_backend()

◆ with_structured_logging()

Member Data Documentation

◆ backend_

◆ built_config_

◆ config_

◆ error_handler_

◆ exclusive_routing_

◆ filters_

◆ formatter_

◆ health_check_interval_

◆ monitor_

◆ routes_

◆ sampler_

◆ strategies_

◆ writers_