kcenon::logger::writer_factory Class Reference

Factory for creating log writer instances. More...

#include <writer_factory.h>

Collaboration diagram for kcenon::logger::writer_factory:

Public Types
using	creator_fn = std::function<log_writer_ptr()>

Static Public Member Functions
static log_writer_ptr	create_console (bool use_stderr=false, bool auto_detect_color=true)
	Create a console writer.
static log_writer_ptr	create_file (const std::string &filename, bool append=true, std::size_t buffer_size=8192)
	Create a file writer.
static log_writer_ptr	create_rotating_file (const std::string &filename, std::size_t max_size, std::size_t max_files, std::size_t check_interval=100)
	Create a rotating file writer (size-based)
static log_writer_ptr	create_rotating_file (const std::string &filename, rotation_type type, std::size_t max_files, std::size_t check_interval=100)
	Create a rotating file writer (time-based)
static log_writer_ptr	create_network (const std::string &host, uint16_t port, network_writer::protocol_type protocol=network_writer::protocol_type::tcp, std::size_t buffer_size=8192, std::chrono::seconds reconnect_interval=std::chrono::seconds(5))
	Create a network writer.
static log_writer_ptr	create_batch (log_writer_ptr writer, std::size_t batch_size=100, std::chrono::milliseconds flush_interval=std::chrono::milliseconds(1000))
	Wrap a writer with batch processing.
static log_writer_ptr	create_development ()
	Create a development preset writer.
static log_writer_ptr	create_production (const std::string &log_directory="./logs", const std::string &filename="app.log")
	Create a production preset writer.
static log_writer_ptr	create_high_performance (const std::string &filename="./logs/app.log")
	Create a high-performance preset writer.
static void	register_type (const std::string &name, creator_fn creator)
	Register a custom writer type.
static log_writer_ptr	create (const std::string &name)
	Create a writer by registered name.
static bool	has_type (const std::string &name)
	Check if a writer type is registered.

Static Private Member Functions
static std::unordered_map< std::string, creator_fn > &	registry ()

Detailed Description

Factory for creating log writer instances.

Provides static factory methods for all built-in writer types and a registry pattern for custom writer types.

Since

2.0.0

Definition at line 40 of file writer_factory.h.

Member Typedef Documentation

creator_fn

using kcenon::logger::writer_factory::creator_fn = std::function<log_writer_ptr()>

Definition at line 42 of file writer_factory.h.

Member Function Documentation

create()

static log_writer_ptr kcenon::logger::writer_factory::create ( const std::string & name )

inlinestatic

Create a writer by registered name.

Parameters

name	Registered type name

Returns

Unique pointer to writer, or nullptr if not found

Definition at line 214 of file writer_factory.h.

                                                        {
        auto it = registry().find(name);
        if (it == registry().end()) {
            return nullptr;
        }
        return it->second();
    }

References registry().

Here is the call graph for this function:

create_batch()

static log_writer_ptr kcenon::logger::writer_factory::create_batch ( log_writer_ptr writer, std::size_t batch_size = 100, std::chrono::milliseconds flush_interval = std::chrono::milliseconds(1000) )

inlinestatic

Wrap a writer with batch processing.

Parameters

writer	The writer to wrap
batch_size	Maximum batch size
flush_interval	Auto-flush interval

Returns

Unique pointer to batch writer

Definition at line 142 of file writer_factory.h.

      {
        batch_writer::config cfg;
        cfg.max_batch_size = batch_size;
        cfg.flush_interval = flush_interval;
        return std::make_unique<batch_writer>(std::move(writer), cfg);
    }

References kcenon::logger::batch_writer::config::flush_interval, and kcenon::logger::batch_writer::config::max_batch_size.

Referenced by create_high_performance(), and create_production().

Here is the caller graph for this function:

create_console()

static log_writer_ptr kcenon::logger::writer_factory::create_console ( bool use_stderr = false, bool auto_detect_color = true )

inlinestatic

Create a console writer.

Parameters

use_stderr	Send output to stderr (default: stdout)
auto_detect_color	Auto-detect terminal color support

Returns

Unique pointer to console writer

Definition at line 54 of file writer_factory.h.

      {
        return std::make_unique<console_writer>(use_stderr, auto_detect_color);
    }

Referenced by create_development().

Here is the caller graph for this function:

create_development()

static log_writer_ptr kcenon::logger::writer_factory::create_development ( )

inlinestatic

Create a development preset writer.

Returns

Console writer with colors enabled

Definition at line 161 of file writer_factory.h.

                                               {
        return create_console(false, true);
    }

References create_console().

Here is the call graph for this function:

create_file()

static log_writer_ptr kcenon::logger::writer_factory::create_file ( const std::string & filename, bool append = true, std::size_t buffer_size = 8192 )

inlinestatic

Create a file writer.

Parameters

filename	Path to log file
append	Append to existing file (default: true)
buffer_size	Output buffer size

Returns

Unique pointer to file writer

Definition at line 68 of file writer_factory.h.

      {
        return std::make_unique<file_writer>(filename, append, buffer_size);
    }

create_high_performance()

static log_writer_ptr kcenon::logger::writer_factory::create_high_performance ( const std::string & filename = "./logs/app.log" )

inlinestatic

Create a high-performance preset writer.

Parameters

filename

Log file path

Returns

Batched file writer with large buffers

Definition at line 189 of file writer_factory.h.

      {
        auto file = std::make_unique<file_writer>(filename, true, 65536);
        return create_batch(std::move(file), 500, std::chrono::milliseconds(5000));
    }

References create_batch().

Here is the call graph for this function:

create_network()

static log_writer_ptr kcenon::logger::writer_factory::create_network ( const std::string & host, uint16_t port, network_writer::protocol_type protocol = network_writer::protocol_type::tcp, std::size_t buffer_size = 8192, std::chrono::seconds reconnect_interval = std::chrono::seconds(5) )

inlinestatic

Create a network writer.

Parameters

host	Remote host address
port	Remote port
protocol	Network protocol (TCP/UDP)
buffer_size	Internal buffer size
reconnect_interval	Reconnection interval

Returns

Unique pointer to network writer

Definition at line 123 of file writer_factory.h.

      {
        return std::make_unique<network_writer>(
            host, port, protocol, buffer_size, reconnect_interval
        );
    }

create_production()

static log_writer_ptr kcenon::logger::writer_factory::create_production ( const std::string & log_directory = "./logs", const std::string & filename = "app.log" )

inlinestatic

Create a production preset writer.

Parameters

log_directory	Directory for log files
filename	Log file name

Returns

Batched rotating file writer

Definition at line 171 of file writer_factory.h.

      {
        std::string full_path = log_directory + "/" + filename;
        auto rotating = create_rotating_file(
            full_path,
            100 * 1024 * 1024,  // 100MB
            10
        );
        return create_batch(std::move(rotating), 200, std::chrono::milliseconds(2000));
    }

References create_batch(), and create_rotating_file().

Here is the call graph for this function:

create_rotating_file() [1/2]

static log_writer_ptr kcenon::logger::writer_factory::create_rotating_file ( const std::string & filename, rotation_type type, std::size_t max_files, std::size_t check_interval = 100 )

inlinestatic

Create a rotating file writer (time-based)

Parameters

filename	Path to log file
type	Rotation type (daily/hourly)
max_files	Maximum number of backup files
check_interval	Writes between rotation checks

Returns

Unique pointer to rotating file writer

Definition at line 103 of file writer_factory.h.

      {
        return std::make_unique<rotating_file_writer>(
            filename, type, max_files, check_interval
        );
    }

create_rotating_file() [2/2]

static log_writer_ptr kcenon::logger::writer_factory::create_rotating_file ( const std::string & filename, std::size_t max_size, std::size_t max_files, std::size_t check_interval = 100 )

inlinestatic

Create a rotating file writer (size-based)

Parameters

filename	Path to log file
max_size	Maximum file size before rotation
max_files	Maximum number of backup files
check_interval	Writes between rotation checks

Returns

Unique pointer to rotating file writer

Definition at line 84 of file writer_factory.h.

      {
        return std::make_unique<rotating_file_writer>(
            filename, max_size, max_files, check_interval
        );
    }

Referenced by create_production().

Here is the caller graph for this function:

has_type()

static bool kcenon::logger::writer_factory::has_type ( const std::string & name )

inlinestatic

Check if a writer type is registered.

Parameters

name	Type name to check

Returns

true if registered

Definition at line 227 of file writer_factory.h.

                                                {
        return registry().find(name) != registry().end();
    }

References registry().

Here is the call graph for this function:

register_type()

static void kcenon::logger::writer_factory::register_type ( const std::string & name, creator_fn creator )

inlinestatic

Register a custom writer type.

Parameters

name	Type name for the writer
creator	Factory function to create the writer

Definition at line 205 of file writer_factory.h.

                                                                         {
        registry()[name] = std::move(creator);
    }

References registry().

Here is the call graph for this function:

registry()

static std::unordered_map< std::string, creator_fn > & kcenon::logger::writer_factory::registry ( )

inlinestaticprivate

Definition at line 232 of file writer_factory.h.

                                                               {
        static std::unordered_map<std::string, creator_fn> instance;
        return instance;
    }

Referenced by create(), has_type(), and register_type().

Here is the caller graph for this function:

---

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

• include/kcenon/logger/factories/writer_factory.h