json_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 {
 
class json_formatter : public log_formatter_interface {
public:
    explicit json_formatter(const format_options& opts = format_options{}) {
        options_ = opts;
        // JSON doesn't support colors
        options_.use_colors = false;
    }
 
    std::string format(const log_entry& entry) const override {
        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();
    }
 
    std::string get_name() const override {
        return "json_formatter";
    }
 
private:
    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 << "\"" << 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);
    }
 
    // Note: Formatting functions moved to utils::time_utils and utils::string_utils (Phase 3.4)
    // This reduces code duplication and improves maintainability.
};
 
} // namespace kcenon::logger