template_formatter.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "../interfaces/log_entry.h"
#include "../interfaces/log_formatter_interface.h"
#include "../utils/time_utils.h"
#include "../utils/string_utils.h"
#include <sstream>
#include <iomanip>
#include <vector>
#include <type_traits>
#include <variant>
 
// Use common_system's standard interface
#include <kcenon/common/interfaces/logger_interface.h>
 
namespace kcenon::logger {
 
class template_formatter : public log_formatter_interface {
public:
    static constexpr const char* DEFAULT_TEMPLATE =
        "[{timestamp}] [{level}] [{thread_id}] {message}";
 
    explicit template_formatter(
        const std::string& template_pattern = DEFAULT_TEMPLATE,
        const format_options& opts = format_options{}
    ) : template_(template_pattern) {
        options_ = opts;
        parse_template();
    }
 
    [[nodiscard]] std::string format(const log_entry& entry) const override {
        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();
    }
 
    [[nodiscard]] std::string get_name() const override {
        return "template_formatter";
    }
 
    [[nodiscard]] const std::string& get_template() const {
        return template_;
    }
 
    void set_template(const std::string& template_pattern) {
        template_ = template_pattern;
        parse_template();
    }
 
private:
    struct template_segment {
        std::string content;       
        bool is_placeholder;       
        int width;                 
 
        template_segment(const std::string& c, bool p, int w = 0)
            : content(c), is_placeholder(p), width(w) {}
    };
 
    std::string template_;                      
    std::vector<template_segment> segments_;    
 
    void parse_template() {
        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;
        }
    }
 
    [[nodiscard]] std::string resolve_placeholder(
        const std::string& name,
        int width,
        const log_entry& entry
    ) const {
        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;
    }
 
    [[nodiscard]] static std::string format_field_value(const log_value& value) {
        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);
    }
 
    [[nodiscard]] static size_t calculate_display_width(const std::string& str) {
        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;
    }
};
 
} // namespace kcenon::logger