Customizable formatter using template strings with placeholders. More...

#include <template_formatter.h>

Inheritance diagram for kcenon::logger::template_formatter:

Collaboration diagram for kcenon::logger::template_formatter:

Classes
struct	template_segment
	Segment of parsed template. More...

Public Member Functions
	template_formatter (const std::string &template_pattern=DEFAULT_TEMPLATE, const format_options &opts=format_options{})

std::string	format (const log_entry &entry) const override
	Format a log entry using the template.

std::string	get_name () const override
	Get formatter name.

const std::string &	get_template () const
	Get current template pattern.

void	set_template (const std::string &template_pattern)
	Set a new template pattern.

Public Member Functions inherited from kcenon::logger::log_formatter_interface
virtual	~log_formatter_interface ()=default

virtual void	set_options (const format_options &opts)
	Set formatting options.

virtual format_options	get_options () const
	Get current formatting options.

Static Public Attributes
static constexpr const char *	DEFAULT_TEMPLATE
	Default template pattern.

Private Member Functions
void	parse_template ()
	Parse template string into segments.

std::string	resolve_placeholder (const std::string &name, int width, const log_entry &entry) const
	Resolve a placeholder to its actual value.

Static Private Member Functions
static std::string	format_field_value (const log_value &value)
	Format a structured field value to string.

static size_t	calculate_display_width (const std::string &str)
	Calculate display width excluding ANSI escape codes.

Private Attributes
std::string	template_
	Original template string.

std::vector< template_segment >	segments_
	Parsed template segments.

Additional Inherited Members
Protected Attributes inherited from kcenon::logger::log_formatter_interface
format_options	options_

Detailed Description

Customizable formatter using template strings with placeholders.

Provides flexible log formatting by allowing users to define their own output format using a template string with placeholders. This enables adaptation to various logging requirements without creating new formatter classes.

Features:

User-defined template strings
Multiple placeholder types for all log entry fields
Optional color support for terminal output
Field width formatting (e.g., {level:8} for 8-char width)
Fallback values for missing fields

Thread-safety: This formatter is thread-safe once constructed.

Since: 3.1.0

Examples: structured_logging_example.cpp.

Definition at line 87 of file template_formatter.h.

Constructor & Destructor Documentation

◆ template_formatter()

kcenon::logger::template_formatter::template_formatter	(	const std::string &	template_pattern = DEFAULT_TEMPLATE,
		const format_options &	opts = format_options{} )

inlineexplicit

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 110 of file template_formatter.h.

                                                   {}
    ) : template_(template_pattern) {
        options_ = opts;
        parse_template();
    }

Member Function Documentation

◆ calculate_display_width()

static size_t kcenon::logger::template_formatter::calculate_display_width ( const std::string & str )

inlinestaticnodiscardprivate

Calculate display width excluding ANSI escape codes.

Parameters

str	String that may contain ANSI codes

Returns: Display width in characters

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 368 of file template_formatter.h.

                                                                              {
        size_t width = 0;
        bool in_escape = false;
 
        for (size_t i = 0; i < str.length(); ++i) {
            if (str[i] == '\033') {
                in_escape = true;
            } else if (in_escape) {
                if (str[i] == 'm') {
                    in_escape = false;
                }
            } else {
                ++width;
            }
        }
 
        return width;
    }

Referenced by resolve_placeholder().

Here is the caller graph for this function:

◆ format()

std::string kcenon::logger::template_formatter::format ( const log_entry & entry ) const

inlinenodiscardoverridevirtual

Format a log entry using the template.

Parameters

entry The log entry to format

Returns: Formatted string according to template

Replaces all placeholders in the template with actual values from the log entry. Missing optional fields are replaced with empty strings or default values.

Note: Thread-safe. Can be called concurrently.

Since: 3.1.0

Implements kcenon::logger::log_formatter_interface.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 131 of file template_formatter.h.

                                                                          {
        std::ostringstream oss;
 
        for (const auto& segment : segments_) {
            if (segment.is_placeholder) {
                oss << resolve_placeholder(segment.content, segment.width, entry);
            } else {
                oss << segment.content;
            }
        }
 
        return oss.str();
    }

References resolve_placeholder(), and segments_.

Referenced by template_formatter_example().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ format_field_value()

static std::string kcenon::logger::template_formatter::format_field_value ( const log_value & value )

inlinestaticnodiscardprivate

Format a structured field value to string.

Parameters

value The log_value to format

Returns: String representation

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 344 of file template_formatter.h.

                                                                              {
        return std::visit([](const auto& v) -> std::string {
            using T = std::decay_t<decltype(v)>;
            if constexpr (std::is_same_v<T, std::string>) {
                return v;
            } else if constexpr (std::is_same_v<T, bool>) {
                return v ? "true" : "false";
            } else if constexpr (std::is_same_v<T, int64_t>) {
                return std::to_string(v);
            } else if constexpr (std::is_same_v<T, double>) {
                std::ostringstream oss;
                oss << std::fixed << std::setprecision(6) << v;
                return oss.str();
            } else {
                return std::to_string(v);
            }
        }, value);
    }

Referenced by resolve_placeholder().

Here is the caller graph for this function:

◆ get_name()

std::string kcenon::logger::template_formatter::get_name ( ) const

inlinenodiscardoverridevirtual

Get formatter name.

Returns: "template_formatter"

Since: 3.1.0

Implements kcenon::logger::log_formatter_interface.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 151 of file template_formatter.h.

                                                      {
        return "template_formatter";
    }

◆ get_template()

const std::string & kcenon::logger::template_formatter::get_template ( ) const

inlinenodiscard

Get current template pattern.

Returns: The template string used for formatting

Since: 3.1.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 161 of file template_formatter.h.

                                                        {
        return template_;
    }

References template_.

◆ parse_template()

void kcenon::logger::template_formatter::parse_template ( )

inlineprivate

Parse template string into segments.

Breaks down the template into literal text segments and placeholder segments for efficient formatting.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 200 of file template_formatter.h.

                          {
        segments_.clear();
 
        size_t pos = 0;
        size_t len = template_.length();
 
        while (pos < len) {
            size_t start = template_.find('{', pos);
 
            if (start == std::string::npos) {
                // No more placeholders, add remaining text
                if (pos < len) {
                    segments_.emplace_back(template_.substr(pos), false);
                }
                break;
            }
 
            // Add text before placeholder
            if (start > pos) {
                segments_.emplace_back(template_.substr(pos, start - pos), false);
            }
 
            // Find closing brace
            size_t end = template_.find('}', start);
            if (end == std::string::npos) {
                // Unclosed brace, treat as literal
                segments_.emplace_back(template_.substr(start), false);
                break;
            }
 
            // Extract placeholder name and optional width
            std::string placeholder = template_.substr(start + 1, end - start - 1);
            int width = 0;
 
            size_t colon_pos = placeholder.find(':');
            if (colon_pos != std::string::npos) {
                std::string width_str = placeholder.substr(colon_pos + 1);
                placeholder = placeholder.substr(0, colon_pos);
                try {
                    width = std::stoi(width_str);
                } catch (...) {
                    width = 0;
                }
            }
 
            segments_.emplace_back(placeholder, true, width);
            pos = end + 1;
        }
    }

References segments_, and template_.

Referenced by set_template().

Here is the caller graph for this function:

◆ resolve_placeholder()

std::string kcenon::logger::template_formatter::resolve_placeholder	(	const std::string &	name,
		int	width,
		const log_entry &	entry ) const

inlinenodiscardprivate

Resolve a placeholder to its actual value.

Parameters

name	Placeholder name
width	Optional field width
entry	Log entry to extract value from

Returns: Resolved value string

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 257 of file template_formatter.h.

            {
        std::string value;
 
        if (name == "timestamp") {
            value = utils::time_utils::format_iso8601(entry.timestamp);
        } else if (name == "timestamp_local") {
            value = utils::time_utils::format_timestamp(entry.timestamp);
        } else if (name == "level") {
            std::string level_str = utils::string_utils::level_to_string(entry.level);
            if (options_.use_colors) {
                value = utils::string_utils::level_to_color(entry.level) +
                        level_str +
                        utils::string_utils::color_reset();
            } else {
                value = level_str;
            }
        } else if (name == "level_lower") {
            value = utils::string_utils::to_lower(
                utils::string_utils::level_to_string(entry.level)
            );
        } else if (name == "message") {
            value = entry.message.to_string();
        } else if (name == "thread_id") {
            if (entry.thread_id) {
                value = entry.thread_id->to_string();
            }
        } else if (name == "file") {
            if (entry.location) {
                value = entry.location->file.to_string();
            }
        } else if (name == "filename") {
            if (entry.location) {
                value = utils::string_utils::extract_filename(
                    entry.location->file.to_string()
                );
            }
        } else if (name == "line") {
            if (entry.location && entry.location->line > 0) {
                value = std::to_string(entry.location->line);
            }
        } else if (name == "function") {
            if (entry.location) {
                value = entry.location->function.to_string();
            }
        } else if (name == "category") {
            if (entry.category) {
                value = entry.category->to_string();
            }
        } else if (name == "trace_id") {
            if (entry.otel_ctx && !entry.otel_ctx->trace_id.empty()) {
                value = entry.otel_ctx->trace_id;
            }
        } else if (name == "span_id") {
            if (entry.otel_ctx && !entry.otel_ctx->span_id.empty()) {
                value = entry.otel_ctx->span_id;
            }
        } else {
            // Check structured fields
            if (entry.fields) {
                auto it = entry.fields->find(name);
                if (it != entry.fields->end()) {
                    value = format_field_value(it->second);
                }
            }
        }
 
        // Apply width formatting if specified
        if (width > 0 && !value.empty()) {
            // Calculate actual display width (excluding ANSI codes)
            size_t display_len = calculate_display_width(value);
            if (display_len < static_cast<size_t>(width)) {
                value += std::string(width - display_len, ' ');
            }
        }
 
        return value;
    }

Referenced by format().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_template()

void kcenon::logger::template_formatter::set_template ( const std::string & template_pattern )

inline

Set a new template pattern.

Parameters

template_pattern New template string

Note: This method re-parses the template.

Since: 3.1.0

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 173 of file template_formatter.h.

                                                         {
        template_ = template_pattern;
        parse_template();
    }

References parse_template(), and template_.

Referenced by template_formatter_example().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ DEFAULT_TEMPLATE

const char* kcenon::logger::template_formatter::DEFAULT_TEMPLATE

staticconstexpr

Initial value:

=

"[{timestamp}] [{level}] [{thread_id}] {message}"

Default template pattern.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 92 of file template_formatter.h.

◆ segments_

std::vector<template_segment> kcenon::logger::template_formatter::segments_

private

Parsed template segments.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 192 of file template_formatter.h.

Referenced by format(), and parse_template().

◆ template_

std::string kcenon::logger::template_formatter::template_

private

Original template string.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 191 of file template_formatter.h.

Referenced by get_template(), parse_template(), and set_template().

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

include/kcenon/logger/formatters/template_formatter.h

Classes

Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ template_formatter()

Member Function Documentation

◆ calculate_display_width()

◆ format()

◆ format_field_value()

◆ get_name()

◆ get_template()

◆ parse_template()

◆ resolve_placeholder()

◆ set_template()

Member Data Documentation

◆ DEFAULT_TEMPLATE

◆ segments_

◆ template_