log_context_scope.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/logger/logger_export.h>
 
#include <algorithm>
#include <optional>
#include <string>
#include <vector>
 
namespace kcenon::logger {
 
// Forward declaration
class logger;
 
class log_context_storage {
public:
    static void set(const std::string& key, const std::string& value) {
        get_storage()[key] = value;
        get_has_context() = true;
    }
 
    static void set(const std::string& key, const char* value) {
        get_storage()[key] = std::string(value);
        get_has_context() = true;
    }
 
    static void set(const std::string& key, int64_t value) {
        get_storage()[key] = value;
        get_has_context() = true;
    }
 
    static void set(const std::string& key, double value) {
        get_storage()[key] = value;
        get_has_context() = true;
    }
 
    static void set(const std::string& key, bool value) {
        get_storage()[key] = value;
        get_has_context() = true;
    }
 
    static void set(const std::string& key, const log_value& value) {
        get_storage()[key] = value;
        get_has_context() = true;
    }
 
    static void set_all(const log_fields& fields) {
        for (const auto& [key, value] : fields) {
            get_storage()[key] = value;
        }
        if (!fields.empty()) {
            get_has_context() = true;
        }
    }
 
    static void remove(const std::string& key) {
        get_storage().erase(key);
        if (get_storage().empty()) {
            get_has_context() = false;
        }
    }
 
    [[nodiscard]] static log_fields get() {
        if (get_has_context()) {
            return get_storage();
        }
        return {};
    }
 
    static void clear() {
        get_storage().clear();
        get_has_context() = false;
    }
 
    [[nodiscard]] static bool has_context() {
        return get_has_context();
    }
 
    [[nodiscard]] static std::optional<log_value> get_field(const std::string& key) {
        if (!get_has_context()) {
            return std::nullopt;
        }
        auto& storage = get_storage();
        auto it = storage.find(key);
        if (it != storage.end()) {
            return it->second;
        }
        return std::nullopt;
    }
 
private:
    static log_fields& get_storage() {
        thread_local log_fields storage;
        return storage;
    }
 
    static bool& get_has_context() {
        thread_local bool has_ctx = false;
        return has_ctx;
    }
};
 
class LOGGER_SYSTEM_API log_context_scope {
public:
    explicit log_context_scope(const log_fields& fields)
        : previous_context_(log_context_storage::get()),
          had_previous_(log_context_storage::has_context()) {
        for (const auto& [key, value] : fields) {
            // Track which keys we're adding (to remove them on destruction)
            if (previous_context_.find(key) == previous_context_.end()) {
                added_keys_.push_back(key);
            }
            log_context_storage::set(key, value);
        }
    }
 
    log_context_scope(logger& log, const log_fields& fields);
 
    ~log_context_scope() {
        // Remove keys that were added by this scope
        for (const auto& key : added_keys_) {
            log_context_storage::remove(key);
        }
 
        // Restore overridden values from previous context
        if (had_previous_) {
            for (const auto& [key, value] : previous_context_) {
                // Only restore if the key was overridden (not newly added)
                if (std::find(added_keys_.begin(), added_keys_.end(), key) == added_keys_.end()) {
                    log_context_storage::set(key, value);
                }
            }
        }
 
        // Clear logger context if we set it
        if (logger_ != nullptr) {
            for (const auto& key : added_keys_) {
                remove_logger_context(key);
            }
        }
    }
 
    // Non-copyable, non-movable
    log_context_scope(const log_context_scope&) = delete;
    log_context_scope& operator=(const log_context_scope&) = delete;
    log_context_scope(log_context_scope&&) = delete;
    log_context_scope& operator=(log_context_scope&&) = delete;
 
private:
    void remove_logger_context(const std::string& key);
 
    log_fields previous_context_;
    bool had_previous_;
    std::vector<std::string> added_keys_;
    logger* logger_ = nullptr;
};
 
class scoped_context {
public:
    scoped_context(const std::string& key, const std::string& value)
        : key_(key), had_previous_(false) {
        auto prev = log_context_storage::get_field(key);
        if (prev) {
            had_previous_ = true;
            previous_value_ = *prev;
        }
        log_context_storage::set(key, value);
    }
 
    scoped_context(const std::string& key, int64_t value)
        : key_(key), had_previous_(false) {
        auto prev = log_context_storage::get_field(key);
        if (prev) {
            had_previous_ = true;
            previous_value_ = *prev;
        }
        log_context_storage::set(key, value);
    }
 
    scoped_context(const std::string& key, int value)
        : scoped_context(key, static_cast<int64_t>(value)) {}
 
    scoped_context(const std::string& key, double value)
        : key_(key), had_previous_(false) {
        auto prev = log_context_storage::get_field(key);
        if (prev) {
            had_previous_ = true;
            previous_value_ = *prev;
        }
        log_context_storage::set(key, value);
    }
 
    scoped_context(const std::string& key, bool value)
        : key_(key), had_previous_(false) {
        auto prev = log_context_storage::get_field(key);
        if (prev) {
            had_previous_ = true;
            previous_value_ = *prev;
        }
        log_context_storage::set(key, value);
    }
 
    ~scoped_context() {
        if (had_previous_) {
            log_context_storage::set(key_, previous_value_);
        } else {
            log_context_storage::remove(key_);
        }
    }
 
    // Non-copyable, non-movable
    scoped_context(const scoped_context&) = delete;
    scoped_context& operator=(const scoped_context&) = delete;
    scoped_context(scoped_context&&) = delete;
    scoped_context& operator=(scoped_context&&) = delete;
 
private:
    std::string key_;
    log_value previous_value_;
    bool had_previous_;
};
 
} // namespace kcenon::logger