logfmt_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 <type_traits>
#include <variant>
 
// Use common_system's standard interface
#include <kcenon/common/interfaces/logger_interface.h>
 
namespace kcenon::logger {
 
// Type alias for log_level
using log_level = common::interfaces::log_level;
 
class logfmt_formatter : public log_formatter_interface {
public:
    explicit logfmt_formatter(const format_options& opts = format_options{}) {
        options_ = opts;
        // Logfmt doesn't support colors or pretty print
        options_.use_colors = false;
        options_.pretty_print = false;
    }
 
    [[nodiscard]] std::string format(const log_entry& entry) const override {
        std::ostringstream oss;
        bool first = true;
 
        // Level
        if (options_.include_level) {
            oss << "level=" << level_to_lowercase(entry.level);
            first = false;
        }
 
        // Timestamp (ISO 8601)
        if (options_.include_timestamp) {
            if (!first) {
                oss << " ";
            }
            oss << "ts=" << utils::time_utils::format_iso8601(entry.timestamp);
            first = false;
        }
 
        // Message (always include)
        if (!first) {
            oss << " ";
        }
        oss << "msg=" << escape_logfmt_value(entry.message.to_string());
        first = false;
 
        // Thread ID
        if (options_.include_thread_id && entry.thread_id) {
            oss << " thread_id=" << escape_logfmt_value(entry.thread_id->to_string());
        }
 
        // Source location
        if (options_.include_source_location && entry.location) {
            std::string file_path = entry.location->file.to_string();
            if (!file_path.empty()) {
                oss << " file=" << escape_logfmt_value(file_path);
            }
 
            if (entry.location->line > 0) {
                oss << " line=" << entry.location->line;
            }
 
            std::string func = entry.location->function.to_string();
            if (!func.empty()) {
                oss << " function=" << escape_logfmt_value(func);
            }
        }
 
        // Category (if present)
        if (entry.category) {
            std::string cat = entry.category->to_string();
            if (!cat.empty()) {
                oss << " category=" << escape_logfmt_value(cat);
            }
        }
 
        // OpenTelemetry context (if present)
        if (entry.otel_ctx && entry.otel_ctx->is_valid()) {
            if (!entry.otel_ctx->trace_id.empty()) {
                oss << " trace_id=" << entry.otel_ctx->trace_id;
            }
            if (!entry.otel_ctx->span_id.empty()) {
                oss << " span_id=" << entry.otel_ctx->span_id;
            }
            if (!entry.otel_ctx->trace_flags.empty()) {
                oss << " trace_flags=" << entry.otel_ctx->trace_flags;
            }
        }
 
        // Structured fields (if present)
        if (entry.fields && !entry.fields->empty()) {
            for (const auto& [key, value] : *entry.fields) {
                oss << " " << escape_logfmt_key(key) << "=";
                format_value(oss, value);
            }
        }
 
        return oss.str();
    }
 
    [[nodiscard]] std::string get_name() const override {
        return "logfmt_formatter";
    }
 
private:
    static std::string level_to_lowercase(log_level level) {
        switch (level) {
            case log_level::trace: return "trace";
            case log_level::debug: return "debug";
            case log_level::info: return "info";
            case log_level::warning: return "warn";
            case log_level::error: return "error";
            case log_level::critical: return "critical";
            case log_level::off: return "off";
            default: return "unknown";
        }
    }
 
    static std::string escape_logfmt_key(const std::string& key) {
        std::string result;
        result.reserve(key.size());
        for (char c : key) {
            if (c == ' ' || c == '=' || c == '"' || c == '\n' || c == '\t') {
                result += '_';
            } else {
                result += c;
            }
        }
        return result;
    }
 
    static std::string escape_logfmt_value(const std::string& value) {
        // Check if quoting is needed
        bool needs_quoting = false;
        for (char c : value) {
            if (c == ' ' || c == '"' || c == '=' || c == '\n' || c == '\t' || c == '\r') {
                needs_quoting = true;
                break;
            }
        }
 
        if (!needs_quoting && !value.empty()) {
            return value;
        }
 
        // Quote and escape
        std::ostringstream oss;
        oss << '"';
        for (char c : value) {
            switch (c) {
                case '"': oss << "\\\""; break;
                case '\\': oss << "\\\\"; break;
                case '\n': oss << "\\n"; break;
                case '\r': oss << "\\r"; break;
                case '\t': oss << "\\t"; break;
                default: oss << c;
            }
        }
        oss << '"';
        return oss.str();
    }
 
    static void format_value(std::ostringstream& oss, const log_value& value) {
        std::visit([&oss](const auto& v) {
            using T = std::decay_t<decltype(v)>;
            if constexpr (std::is_same_v<T, std::string>) {
                oss << escape_logfmt_value(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);
    }
};
 
} // namespace kcenon::logger