structured_log_builder.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 <kcenon/logger/interfaces/log_entry.h>
#include <kcenon/common/interfaces/logger_interface.h>
 
#include <string>
#include <functional>
 
namespace kcenon::logger {
 
// Type alias for log_level
using log_level = common::interfaces::log_level;
 
// Forward declaration
class logger;
 
class structured_log_builder {
public:
    using emit_callback = std::function<void(log_entry&&)>;
 
    structured_log_builder(log_level level,
                           emit_callback callback,
                           const log_fields* context_fields = nullptr)
        : level_(level),
          callback_(std::move(callback)) {
        if (context_fields && !context_fields->empty()) {
            fields_ = *context_fields;
        }
    }
 
    structured_log_builder& message(const std::string& msg) {
        message_ = msg;
        return *this;
    }
 
    structured_log_builder& field(const std::string& key, const std::string& value) {
        fields_[key] = value;
        return *this;
    }
 
    structured_log_builder& field(const std::string& key, const char* value) {
        fields_[key] = std::string(value);
        return *this;
    }
 
    structured_log_builder& field(const std::string& key, int value) {
        fields_[key] = static_cast<int64_t>(value);
        return *this;
    }
 
    structured_log_builder& field(const std::string& key, int64_t value) {
        fields_[key] = value;
        return *this;
    }
 
    structured_log_builder& field(const std::string& key, double value) {
        fields_[key] = value;
        return *this;
    }
 
    structured_log_builder& field(const std::string& key, bool value) {
        fields_[key] = value;
        return *this;
    }
 
    structured_log_builder& field(const std::string& key, const log_value& value) {
        fields_[key] = value;
        return *this;
    }
 
    structured_log_builder& category(const std::string& cat) {
        category_ = cat;
        return *this;
    }
 
    void emit() {
        if (!callback_) {
            return;
        }
 
        log_entry entry(level_, message_);
 
        if (!fields_.empty()) {
            entry.fields = std::move(fields_);
        }
 
        if (!category_.empty()) {
            entry.category = small_string_128(category_);
        }
 
        callback_(std::move(entry));
    }
 
    ~structured_log_builder() = default;
 
    // Disable copy
    structured_log_builder(const structured_log_builder&) = delete;
    structured_log_builder& operator=(const structured_log_builder&) = delete;
 
    // Enable move
    structured_log_builder(structured_log_builder&&) noexcept = default;
    structured_log_builder& operator=(structured_log_builder&&) noexcept = default;
 
private:
    log_level level_;
    emit_callback callback_;
    std::string message_;
    std::string category_;
    log_fields fields_;
};
 
} // namespace kcenon::logger