SimpleLogFormatter.hpp

Go to the documentation of this file.

#pragma once
#ifndef _LOGIT_SIMPLE_LOG_FORMATTER_HPP_INCLUDED
#define _LOGIT_SIMPLE_LOG_FORMATTER_HPP_INCLUDED

 
#include "ILogFormatter.hpp"
#include "compiler/PatternCompiler.hpp"
#include <time_shield/time_conversions.hpp>
#include <atomic>  // for std::atomic
 
namespace logit {

    class SimpleLogFormatter : public ILogFormatter {
    public:
        struct Config {
            std::string pattern = "[%Y-%m-%d %H:%M:%S.%e] [%ffn:%#] [%!] [thread:%t] [%l] %^%v%$"; 
            bool json_format = false; 
        };

        SimpleLogFormatter() {
            compile_pattern();
        }

        SimpleLogFormatter(const std::string& pattern, const bool json_format = false) {
            set_pattern(pattern, json_format);
        }

        void set_pattern(const std::string& pattern, bool json_format = false) {
            m_config.pattern = pattern;
            m_config.json_format = json_format;
            compile_pattern();
        }

        void set_timestamp_offset(int64_t offset_ms) override {
            m_offset_ms = offset_ms;
        }

        std::string format(const LogRecord& record) const override {
            if (m_config.json_format) {
                return format_as_json(record);
            } else {
                return format_as_pattern(record);
            }
        }
 
    private:
        Config m_config;                                        
        std::vector<FormatInstruction> m_compiled_instructions; 
        std::atomic<int64_t> m_offset_ms = ATOMIC_VAR_INIT(0);  

        void compile_pattern() {
            m_compiled_instructions = PatternCompiler::compile(m_config.pattern);
        }

        std::string format_as_pattern(const LogRecord& record) const {
            auto dt = time_shield::to_date_time_ms<time_shield::DateTimeStruct>(record.timestamp_ms + m_offset_ms);
            std::ostringstream oss;
            for (const auto& instruction : m_compiled_instructions) {
                instruction.apply(oss, record, dt);
            }
            return oss.str();
        }

        std::string format_as_json(const LogRecord& record) const {
            std::ostringstream oss;
            oss << "{"
                << "\"log_level\": " << static_cast<int>(record.log_level) << ", "
                << "\"timestamp_ms\": " << record.timestamp_ms << ", "
                << "\"file\": \"" << escape_json_string(record.file) << "\", "
                << "\"line\": " << record.line << ", "
                << "\"function\": \"" << escape_json_string(record.function) << "\", "
                << "\"format\": \"" << escape_json_string(record.format) << "\", "
                << "\"arg_names\": \"" << escape_json_string(record.arg_names) << "\", "
                << "\"args_array\": [";
 
            for (size_t i = 0; i < record.args_array.size(); ++i) {
                if (i > 0) oss << ", ";
                oss << "\"" << escape_json_string(record.args_array[i].to_string()) << "\"";  // Assuming to_string()
            }
 
            oss << "], "
                << "\"thread_id\": \"" << escape_json_string(thread_id_to_string(record.thread_id)) << "\""
                << "}";
 
            return oss.str();
        }

        std::string escape_json_string(const std::string& input) const {
            std::ostringstream oss;
            for (char c : input) {
                switch (c) {
                    case '"': oss << "\\\""; break;
                    case '\\': oss << "\\\\"; break;
                    case '\b': oss << "\\b"; break;
                    case '\f': oss << "\\f"; break;
                    case '\n': oss << "\\n"; break;
                    case '\r': oss << "\\r"; break;
                    case '\t': oss << "\\t"; break;
                    default:
                        if ('\x00' <= c && c <= '\x1f') {
                            oss << "\\u"
                                << std::hex << std::setw(4) << std::setfill('0') << static_cast<int>(c);
                        } else {
                            oss << c;
                        }
                }
            }
            return oss.str();
        }

        std::string thread_id_to_string(const std::thread::id& thread_id) const {
            std::ostringstream oss;
            oss << thread_id;
            return oss.str();
        }
    }; // class SimpleLogFormatter
 
}; // namespace logit
 
#endif // _LOGIT_SIMPLE_LOG_FORMATTER_HPP_INCLUDED