kcenon::logger::formatter_factory Class Reference

Factory for creating log formatter instances. More...

#include <formatter_factory.h>

Collaboration diagram for kcenon::logger::formatter_factory:

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

Static Public Member Functions
static std::unique_ptr< log_formatter_interface >	create_plain (const format_options &opts=format_options{})
	Create a plain/timestamp formatter.
static std::unique_ptr< log_formatter_interface >	create_json (const format_options &opts=format_options{})
	Create a JSON formatter.
static std::unique_ptr< log_formatter_interface >	create_logfmt (const format_options &opts=format_options{})
	Create a logfmt formatter.
static std::unique_ptr< log_formatter_interface >	create_template (const std::string &template_pattern=template_formatter::DEFAULT_TEMPLATE, const format_options &opts=format_options{})
	Create a template formatter with custom pattern.
static std::unique_ptr< log_formatter_interface >	create_compact ()
	Create a compact formatter.
static std::unique_ptr< log_formatter_interface >	create (format_type type, const format_options &opts=format_options{})
	Create a formatter by type enum.
static std::unique_ptr< log_formatter_interface >	create_development ()
	Create a development formatter.
static std::unique_ptr< log_formatter_interface >	create_production ()
	Create a production formatter.
static std::unique_ptr< log_formatter_interface >	create_minimal ()
	Create a minimal formatter.
static void	register_type (const std::string &name, creator_fn creator)
	Register a custom formatter type.
static std::unique_ptr< log_formatter_interface >	create (const std::string &name)
	Create a formatter by registered name.
static bool	has_type (const std::string &name)
	Check if a formatter type is registered.

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

Detailed Description

Factory for creating log formatter instances.

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

Since

2.0.0

Definition at line 50 of file formatter_factory.h.

Member Typedef Documentation

creator_fn

using kcenon::logger::formatter_factory::creator_fn = std::function<std::unique_ptr<log_formatter_interface>()>

Definition at line 52 of file formatter_factory.h.

Member Function Documentation

create() [1/2]

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create ( const std::string & name )

inlinestatic

Create a formatter by registered name.

Parameters

name	Registered type name

Returns

Unique pointer to formatter, or nullptr if not found

Definition at line 211 of file formatter_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() [2/2]

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create ( format_type type, const format_options & opts = format_options{} )

inlinestatic

Create a formatter by type enum.

Parameters

type	Format type
opts	Format options (for customization)

Returns

Unique pointer to formatter

Definition at line 128 of file formatter_factory.h.

                                                   {}
    ) {
        switch (type) {
        case format_type::json:
            return create_json(opts);
        case format_type::logfmt:
            return create_logfmt(opts);
        case format_type::templated:
            return create_template(template_formatter::DEFAULT_TEMPLATE, opts);
        case format_type::compact:
            return create_compact();
        case format_type::plain:
        default:
            return create_plain(opts);
        }
    }

create_compact()

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create_compact ( )

inlinestatic

Create a compact formatter.

Returns

Unique pointer to compact formatter

Compact format: minimal overhead, single line

Definition at line 112 of file formatter_factory.h.

                                                                   {
        format_options opts;
        opts.include_timestamp = true;
        opts.include_thread_id = false;
        opts.include_source_location = false;
        opts.include_level = true;
        opts.use_colors = false;
        return std::make_unique<timestamp_formatter>(opts);
    }

References kcenon::logger::format_options::include_level, kcenon::logger::format_options::include_source_location, kcenon::logger::format_options::include_thread_id, kcenon::logger::format_options::include_timestamp, and kcenon::logger::format_options::use_colors.

create_development()

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create_development ( )

inlinestatic

Create a development formatter.

Returns

Colored timestamp formatter with source location

Definition at line 155 of file formatter_factory.h.

                                                                       {
        format_options opts;
        opts.include_timestamp = true;
        opts.include_thread_id = true;
        opts.include_source_location = true;
        opts.include_level = true;
        opts.use_colors = true;
        return create_plain(opts);
    }

References create_plain(), kcenon::logger::format_options::include_level, kcenon::logger::format_options::include_source_location, kcenon::logger::format_options::include_thread_id, kcenon::logger::format_options::include_timestamp, and kcenon::logger::format_options::use_colors.

Here is the call graph for this function:

create_json()

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create_json ( const format_options & opts = format_options{} )

inlinestatic

Create a JSON formatter.

Parameters

opts	Format options

Returns

Unique pointer to JSON formatter

Definition at line 74 of file formatter_factory.h.

                                                   {}
    ) {
        return std::make_unique<json_formatter>(opts);
    }

Referenced by create_production().

Here is the caller graph for this function:

create_logfmt()

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create_logfmt ( const format_options & opts = format_options{} )

inlinestatic

Create a logfmt formatter.

Parameters

opts	Format options

Returns

Unique pointer to logfmt formatter

Since

3.1.0

Definition at line 86 of file formatter_factory.h.

                                                   {}
    ) {
        return std::make_unique<logfmt_formatter>(opts);
    }

create_minimal()

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create_minimal ( )

inlinestatic

Create a minimal formatter.

Returns

Compact formatter with minimal fields

Definition at line 183 of file formatter_factory.h.

                                                                   {
        format_options opts;
        opts.include_timestamp = false;
        opts.include_thread_id = false;
        opts.include_source_location = false;
        opts.include_level = true;
        opts.use_colors = false;
        return create_plain(opts);
    }

References create_plain(), kcenon::logger::format_options::include_level, kcenon::logger::format_options::include_source_location, kcenon::logger::format_options::include_thread_id, kcenon::logger::format_options::include_timestamp, and kcenon::logger::format_options::use_colors.

Here is the call graph for this function:

create_plain()

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create_plain ( const format_options & opts = format_options{} )

inlinestatic

Create a plain/timestamp formatter.

Parameters

opts	Format options

Returns

Unique pointer to timestamp formatter

Definition at line 63 of file formatter_factory.h.

                                                   {}
    ) {
        return std::make_unique<timestamp_formatter>(opts);
    }

Referenced by create_development(), and create_minimal().

Here is the caller graph for this function:

create_production()

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create_production ( )

inlinestatic

Create a production formatter.

Returns

JSON formatter for structured logging

Definition at line 169 of file formatter_factory.h.

                                                                      {
        format_options opts;
        opts.include_timestamp = true;
        opts.include_thread_id = true;
        opts.include_source_location = false;
        opts.include_level = true;
        opts.use_colors = false;
        return create_json(opts);
    }

References create_json(), kcenon::logger::format_options::include_level, kcenon::logger::format_options::include_source_location, kcenon::logger::format_options::include_thread_id, kcenon::logger::format_options::include_timestamp, and kcenon::logger::format_options::use_colors.

Here is the call graph for this function:

create_template()

static std::unique_ptr< log_formatter_interface > kcenon::logger::formatter_factory::create_template ( const std::string & template_pattern = template_formatter::DEFAULT_TEMPLATE, const format_options & opts = format_options{} )

inlinestatic

Create a template formatter with custom pattern.

Parameters

template_pattern	Template string with placeholders
opts	Format options

Returns

Unique pointer to template formatter

Since

3.1.0

Definition at line 99 of file formatter_factory.h.

                                                   {}
    ) {
        return std::make_unique<template_formatter>(template_pattern, opts);
    }

has_type()

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

inlinestatic

Check if a formatter type is registered.

Parameters

name	Type name to check

Returns

true if registered

Definition at line 224 of file formatter_factory.h.

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

References registry().

Here is the call graph for this function:

register_type()

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

inlinestatic

Register a custom formatter type.

Parameters

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

Definition at line 202 of file formatter_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::formatter_factory::registry ( )

inlinestaticprivate

Definition at line 229 of file formatter_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/formatter_factory.h