kcenon::logger::json_formatter Class Reference

JSON formatter for structured logging. More...

#include <base_formatter.h>

Inheritance diagram for kcenon::logger::json_formatter:

Collaboration diagram for kcenon::logger::json_formatter:

Public Member Functions
std::string	format (const log_entry &entry) const override
	Format a log entry into a string.
std::string	get_format_type () const override
	json_formatter (const format_options &opts=format_options{})
	Constructor with optional format options.
std::string	format (const log_entry &entry) const override
	Format a log entry to JSON string.
std::string	get_name () const override
	Get formatter name.
Public Member Functions inherited from kcenon::logger::base_formatter
virtual	~base_formatter ()=default
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.

Private Member Functions
template<typename StringType >
std::string	escape_json (const StringType &str) const

Static Private Member Functions
static void	format_value (std::ostringstream &oss, const log_value &value)
	Format a log_value to JSON.

Additional Inherited Members
Protected Member Functions inherited from kcenon::logger::base_formatter
std::string	level_to_string (log_level level) const
	Convert log level to string.
std::string	format_timestamp (const std::chrono::system_clock::time_point &timestamp) const
	Format timestamp to ISO8601 string.
std::string	get_thread_id () const
	Get current thread ID as string.
Protected Attributes inherited from kcenon::logger::log_formatter_interface
format_options	options_

Detailed Description

JSON formatter for structured logging.

Formatter that outputs JSON-structured log messages.

Produces machine-readable JSON output suitable for log aggregation, analysis tools, and automated processing. Supports both compact and pretty-printed output formats.

Features:

• ISO 8601 timestamp format (RFC 3339)
• Proper JSON escaping of special characters
• Optional pretty-printing for readability
• Structured source location information
• Compatible with JSON parsers and log aggregation systems

Thread-safety: This formatter is stateless and thread-safe.

Note

This implementation provides basic JSON formatting without external dependencies. For more complex JSON structures, consider integrating nlohmann/json or similar libraries.

Since

1.2.0

Examples

structured_logging_example.cpp.

Definition at line 69 of file json_formatter.h.

Constructor & Destructor Documentation

json_formatter()

kcenon::logger::json_formatter::json_formatter ( const format_options & opts = format_options{} )

inlineexplicit

Constructor with optional format options.

Parameters

opts	Initial format options

Note

For JSON output, use_colors option is ignored

Since

1.2.0

Definition at line 79 of file json_formatter.h.

                                                                       {}) {
        options_ = opts;
        // JSON doesn't support colors
        options_.use_colors = false;
    }

Member Function Documentation

escape_json()

template<typename StringType >

std::string kcenon::logger::json_formatter::escape_json ( const StringType & str ) const

inlineprivate

Definition at line 156 of file base_formatter.h.

                                                       {
        std::ostringstream escaped;
        for (unsigned char c : str) {
            if (c == '"') escaped << "\\\"";
            else if (c == '\\') escaped << "\\\\";
            else if (c == '\n') escaped << "\\n";
            else if (c == '\r') escaped << "\\r";
            else if (c == '\t') escaped << "\\t";
            else if (c == '\b') escaped << "\\b";
            else if (c == '\f') escaped << "\\f";
            // Escape all other control characters (0x00-0x1F) as \uXXXX
            else if (c >= 0x00 && c <= 0x1F) {
                escaped << "\\u"
                       << std::hex << std::setw(4) << std::setfill('0')
                       << static_cast<int>(c);
            }
            else escaped << c;
        }
        return escaped.str();
    }

Referenced by format().

Here is the caller graph for this function:

format() [1/2]

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

inlineoverridevirtual

Format a log entry into a string.

Parameters

entry

The log entry to format

Returns

Formatted string representation

Implements kcenon::logger::base_formatter.

Examples

structured_logging_example.cpp.

Definition at line 124 of file base_formatter.h.

                                                            {
        std::ostringstream oss;
        
        oss << "{";
        oss << "\"timestamp\":\"" << format_timestamp(entry.timestamp) << "\",";
        oss << "\"level\":\"" << level_to_string(entry.level) << "\",";
        oss << "\"message\":\"" << escape_json(entry.message) << "\",";
        oss << "\"thread\":\"" << (entry.thread_id ? std::string(*entry.thread_id) : get_thread_id()) << "\"";
        
        if (entry.location) {
            oss << ",\"location\":{";
            oss << "\"file\":\"" << escape_json(entry.location->file) << "\",";
            oss << "\"line\":" << entry.location->line << ",";
            oss << "\"function\":\"" << escape_json(entry.location->function) << "\"";
            oss << "}";
        }
        
        if (entry.category) {
            oss << ",\"category\":\"" << escape_json(*entry.category) << "\"";
        }
        
        oss << "}";
        
        return oss.str();
    }

References kcenon::logger::log_entry::category, escape_json(), kcenon::logger::base_formatter::format_timestamp(), kcenon::logger::base_formatter::get_thread_id(), kcenon::logger::log_entry::level, kcenon::logger::base_formatter::level_to_string(), kcenon::logger::log_entry::location, kcenon::logger::log_entry::message, kcenon::logger::log_entry::thread_id, and kcenon::logger::log_entry::timestamp.

Referenced by json_formatter_example().

Here is the call graph for this function:

Here is the caller graph for this function:

format() [2/2]

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

inlineoverridevirtual

Format a log entry to JSON string.

Parameters

entry

The log entry to format

Returns

JSON-formatted string

Produces a JSON object with fields:

• timestamp: ISO 8601 format (UTC)
• level: Log level as string
• thread_id: Thread ID as number
• message: Log message (escaped)
• file, line, function: Source location (if enabled)

Note

Thread-safe. Can be called concurrently.

Since

1.2.0

Implements kcenon::logger::base_formatter.

Definition at line 101 of file json_formatter.h.

                                                            {
        std::ostringstream oss;
        const char* indent = options_.pretty_print ? "  " : "";
        const char* newline = options_.pretty_print ? "\n" : "";
 
        oss << "{" << newline;
 
        bool first = true;
 
        // Timestamp (ISO 8601)
        if (options_.include_timestamp) {
            if (!first) oss << "," << newline;
            oss << indent << "\"timestamp\":\"" << utils::time_utils::format_iso8601(entry.timestamp) << "\"";
            first = false;
        }
 
        // Level
        if (options_.include_level) {
            if (!first) oss << "," << newline;
            oss << indent << "\"level\":\"" << utils::string_utils::level_to_string(entry.level) << "\"";
            first = false;
        }
 
        // Thread ID
        if (options_.include_thread_id && entry.thread_id) {
            if (!first) oss << "," << newline;
            oss << indent << "\"thread_id\":\"" << utils::string_utils::escape_json(entry.thread_id->to_string()) << "\"";
            first = false;
        }
 
        // Message (always include)
        if (!first) oss << "," << newline;
        oss << indent << "\"message\":\"" << utils::string_utils::escape_json(entry.message.to_string()) << "\"";
        first = false;
 
        // Source location
        if (options_.include_source_location && entry.location) {
            std::string file_path = entry.location->file.to_string();
            if (!file_path.empty()) {
                oss << "," << newline << indent << "\"file\":\"" << utils::string_utils::escape_json(file_path) << "\"";
            }
 
            if (entry.location->line > 0) {
                oss << "," << newline << indent << "\"line\":" << entry.location->line;
            }
 
            std::string func = entry.location->function.to_string();
            if (!func.empty()) {
                oss << "," << newline << indent << "\"function\":\"" << utils::string_utils::escape_json(func) << "\"";
            }
        }
 
        // Category (if present)
        if (entry.category) {
            std::string cat = entry.category->to_string();
            if (!cat.empty()) {
                oss << "," << newline << indent << "\"category\":\"" << utils::string_utils::escape_json(cat) << "\"";
            }
        }
 
        // OpenTelemetry context (if present)
        if (entry.otel_ctx && entry.otel_ctx->is_valid()) {
            if (!entry.otel_ctx->trace_id.empty()) {
                oss << "," << newline << indent << "\"trace_id\":\"" << utils::string_utils::escape_json(entry.otel_ctx->trace_id) << "\"";
            }
            if (!entry.otel_ctx->span_id.empty()) {
                oss << "," << newline << indent << "\"span_id\":\"" << utils::string_utils::escape_json(entry.otel_ctx->span_id) << "\"";
            }
            if (!entry.otel_ctx->trace_flags.empty()) {
                oss << "," << newline << indent << "\"trace_flags\":\"" << utils::string_utils::escape_json(entry.otel_ctx->trace_flags) << "\"";
            }
        }
 
        // Structured fields (if present)
        if (entry.fields && !entry.fields->empty()) {
            for (const auto& [key, value] : *entry.fields) {
                oss << "," << newline << indent << "\"" << utils::string_utils::escape_json(key) << "\":";
                format_value(oss, value);
            }
        }
 
        oss << newline << "}";
 
        return oss.str();
    }

References kcenon::logger::log_entry::category, kcenon::logger::utils::string_utils::escape_json(), kcenon::logger::log_entry::fields, kcenon::logger::utils::time_utils::format_iso8601(), format_value(), 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, kcenon::logger::log_entry::level, kcenon::logger::utils::string_utils::level_to_string(), kcenon::logger::log_entry::location, kcenon::logger::log_entry::message, kcenon::logger::log_formatter_interface::options_, kcenon::logger::log_entry::otel_ctx, kcenon::logger::format_options::pretty_print, kcenon::logger::log_entry::thread_id, kcenon::logger::log_entry::timestamp, and kcenon::logger::small_string< SSO_SIZE >::to_string().

Here is the call graph for this function:

format_value()

static void kcenon::logger::json_formatter::format_value ( std::ostringstream & oss, const log_value & value )

inlinestaticprivate

Format a log_value to JSON.

Parameters

oss	Output stream
value	Value to format

Definition at line 203 of file json_formatter.h.

                                                                            {
        std::visit([&oss](const auto& v) {
            using T = std::decay_t<decltype(v)>;
            if constexpr (std::is_same_v<T, std::string>) {
                oss << "\"" << utils::string_utils::escape_json(v) << "\"";
            } else if constexpr (std::is_same_v<T, bool>) {
                oss << (v ? "true" : "false");
            } else if constexpr (std::is_same_v<T, int64_t>) {
                oss << v;
            } else if constexpr (std::is_same_v<T, double>) {
                oss << std::fixed << std::setprecision(6) << v;
            } else {
                oss << v;
            }
        }, value);
    }

References kcenon::logger::utils::string_utils::escape_json().

Referenced by format().

Here is the call graph for this function:

Here is the caller graph for this function:

get_format_type()

std::string kcenon::logger::json_formatter::get_format_type ( ) const

inlineoverride

Definition at line 150 of file base_formatter.h.

                                               {
        return "json";
    }

get_name()

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

inlineoverridevirtual

Get formatter name.

Returns

"json_formatter"

Since

1.2.0

Implements kcenon::logger::log_formatter_interface.

Definition at line 193 of file json_formatter.h.

                                        {
        return "json_formatter";
    }

---

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

• include/kcenon/logger/formatters/base_formatter.h
• include/kcenon/logger/formatters/json_formatter.h