otel_context.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 <string>
#include <optional>
#include <unordered_map>
 
namespace kcenon::logger::otlp {
 
struct otel_context {
    std::string trace_id;
 
    std::string span_id;
 
    std::string trace_flags;
 
    std::string trace_state;
 
    [[nodiscard]] bool is_valid() const noexcept {
        return trace_id.length() == 32 && span_id.length() == 16 &&
               is_valid_hex(trace_id) && is_valid_hex(span_id);
    }
 
    [[nodiscard]] bool is_sampled() const noexcept {
        if (trace_flags.empty()) {
            return false;
        }
        // Check if the last character is '1', '3', '5', '7', '9', 'b', 'd', 'f'
        // (odd numbers in hex, meaning bit 0 is set)
        char last = trace_flags.back();
        return (last == '1' || last == '3' || last == '5' || last == '7' ||
                last == '9' || last == 'b' || last == 'd' || last == 'f' ||
                last == 'B' || last == 'D' || last == 'F');
    }
 
    [[nodiscard]] static otel_context empty() noexcept {
        return otel_context{};
    }
 
private:
    [[nodiscard]] static bool is_valid_hex(const std::string& str) noexcept {
        for (char c : str) {
            if (!((c >= '0' && c <= '9') ||
                  (c >= 'a' && c <= 'f') ||
                  (c >= 'A' && c <= 'F'))) {
                return false;
            }
        }
        return true;
    }
};
 
struct otel_resource {
    std::string service_name;
 
    std::string service_version;
 
    std::string service_namespace;
 
    std::string service_instance_id;
 
    std::unordered_map<std::string, std::string> attributes;
};
 
class otel_context_storage {
public:
    static void set(const otel_context& ctx) {
        get_storage() = ctx;
        get_has_context() = true;
    }
 
    [[nodiscard]] static std::optional<otel_context> get() {
        if (get_has_context()) {
            return get_storage();
        }
        return std::nullopt;
    }
 
    static void clear() {
        get_storage() = otel_context{};
        get_has_context() = false;
    }
 
    [[nodiscard]] static bool has_context() {
        return get_has_context();
    }
 
private:
    static otel_context& get_storage() {
        thread_local otel_context storage;
        return storage;
    }
 
    static bool& get_has_context() {
        thread_local bool has_ctx = false;
        return has_ctx;
    }
};
 
class otel_context_scope {
public:
    explicit otel_context_scope(const otel_context& ctx)
        : previous_context_(otel_context_storage::get()),
          had_previous_(otel_context_storage::has_context()) {
        otel_context_storage::set(ctx);
    }
 
    ~otel_context_scope() {
        if (had_previous_) {
            otel_context_storage::set(*previous_context_);
        } else {
            otel_context_storage::clear();
        }
    }
 
    // Non-copyable, non-movable
    otel_context_scope(const otel_context_scope&) = delete;
    otel_context_scope& operator=(const otel_context_scope&) = delete;
    otel_context_scope(otel_context_scope&&) = delete;
    otel_context_scope& operator=(otel_context_scope&&) = delete;
 
private:
    std::optional<otel_context> previous_context_;
    bool had_previous_;
};
 
} // namespace kcenon::logger::otlp