kcenon::logger::unified_log_context Class Reference

Unified interface for managing all types of logging context. More...

#include <unified_log_context.h>

Collaboration diagram for kcenon::logger::unified_log_context:

Classes
struct	entry
	Internal entry structure. More...

Public Member Functions
	unified_log_context ()=default
	Default constructor.
	unified_log_context (const unified_log_context &other)
	Copy constructor.
	unified_log_context (unified_log_context &&other) noexcept
	Move constructor.
unified_log_context &	operator= (const unified_log_context &other)
	Copy assignment operator.
unified_log_context &	operator= (unified_log_context &&other) noexcept
	Move assignment operator.
	~unified_log_context ()=default
	Destructor.
unified_log_context &	set (std::string_view key, context_value value, context_category category=context_category::custom)
	Set a context value.
unified_log_context &	set_trace (std::string_view trace_id, std::string_view span_id, std::optional< std::string_view > parent_span_id=std::nullopt)
	Set trace context.
unified_log_context &	set_request (std::string_view request_id, std::optional< std::string_view > correlation_id=std::nullopt)
	Set request context.
unified_log_context &	set_otel (const otlp::otel_context &ctx)
	Set OpenTelemetry context.
std::optional< context_value >	get (std::string_view key) const
	Get a context value by key.
template<typename T >
std::optional< T >	get_as (std::string_view key) const
std::string	get_string (std::string_view key, std::string_view default_value="") const
	Get a context value as string.
std::optional< context_category >	get_category (std::string_view key) const
	Get the category of a context entry.
bool	has (std::string_view key) const
	Check if a key exists in the context.
bool	empty () const
	Check if the context is empty.
size_t	size () const
	Get the number of entries.
std::vector< std::string >	keys () const
	Get all keys in the context.
std::vector< std::string >	keys (context_category category) const
	Get keys for a specific category.
void	remove (std::string_view key)
	Remove a specific key from the context.
void	clear ()
	Clear all entries from the context.
void	clear (context_category category)
	Clear entries of a specific category.
log_fields	to_fields () const
	Export context to log_fields format.
unified_log_context &	merge (const unified_log_context &other, bool overwrite=true)
	Merge another context into this one.

Private Attributes
std::shared_mutex	mutex_
std::unordered_map< std::string, entry >	data_

Detailed Description

Unified interface for managing all types of logging context.

This class provides a single point of access for all logging context operations. It consolidates what was previously spread across multiple storage mechanisms into one coherent interface.

Thread Safety: All methods are thread-safe. Read operations use shared locks, write operations use exclusive locks.

Definition at line 117 of file unified_log_context.h.

Constructor & Destructor Documentation

unified_log_context() [1/3]

kcenon::logger::unified_log_context::unified_log_context ( )

default

Default constructor.

unified_log_context() [2/3]

kcenon::logger::unified_log_context::unified_log_context

(

const unified_log_context &

other

)

Copy constructor.

Parameters

other

Context to copy from

Definition at line 12 of file unified_log_context.cpp.

                                                                         {
    std::shared_lock lock(other.mutex_);
    data_ = other.data_;
}

References data_, and mutex_.

unified_log_context() [3/3]

kcenon::logger::unified_log_context::unified_log_context ( unified_log_context && other )

noexcept

Move constructor.

Parameters

other

Context to move from

Definition at line 17 of file unified_log_context.cpp.

                                                                             {
    std::unique_lock lock(other.mutex_);
    data_ = std::move(other.data_);
}

~unified_log_context()

kcenon::logger::unified_log_context::~unified_log_context ( )

default

Destructor.

Member Function Documentation

clear() [1/2]

void kcenon::logger::unified_log_context::clear

(

)

Clear all entries from the context.

Definition at line 174 of file unified_log_context.cpp.

                                {
    std::unique_lock lock(mutex_);
    data_.clear();
}

References data_, and mutex_.

clear() [2/2]

void kcenon::logger::unified_log_context::clear

(

context_category

category

)

Clear entries of a specific category.

Parameters

category

Category to clear

Definition at line 179 of file unified_log_context.cpp.

                                                         {
    std::unique_lock lock(mutex_);
    for (auto it = data_.begin(); it != data_.end();) {
        if (it->second.category == category) {
            it = data_.erase(it);
        } else {
            ++it;
        }
    }
}

References data_, and mutex_.

empty()

bool kcenon::logger::unified_log_context::empty ( ) const

nodiscard

Check if the context is empty.

Returns

true if no entries exist

Definition at line 134 of file unified_log_context.cpp.

                                      {
    std::shared_lock lock(mutex_);
    return data_.empty();
}

References data_, and mutex_.

get()

std::optional< context_value > kcenon::logger::unified_log_context::get ( std::string_view key ) const

nodiscard

Get a context value by key.

Parameters

key	Field name

Returns

Optional context value, empty if not found

Definition at line 95 of file unified_log_context.cpp.

                                                                            {
    std::shared_lock lock(mutex_);
    auto it = data_.find(std::string(key));
    if (it != data_.end()) {
        return it->second.value;
    }
    return std::nullopt;
}

References data_, and mutex_.

Referenced by get_string(), and kcenon::logger::scoped_context_guard::~scoped_context_guard().

Here is the caller graph for this function:

get_as()

template<typename T >

std::optional< T > kcenon::logger::unified_log_context::get_as ( std::string_view key ) const

inlinenodiscard

Definition at line 235 of file unified_log_context.h.

                                                                  {
        auto value = get(key);
        if (!value) {
            return std::nullopt;
        }
        if (auto* ptr = std::get_if<T>(&*value)) {
            return *ptr;
        }
        return std::nullopt;
    }

get_category()

std::optional< context_category > kcenon::logger::unified_log_context::get_category ( std::string_view key ) const

nodiscard

Get the category of a context entry.

Parameters

key	Field name

Returns

Optional category, empty if key not found

Definition at line 116 of file unified_log_context.cpp.

                                                                                        {
    std::shared_lock lock(mutex_);
    auto it = data_.find(std::string(key));
    if (it != data_.end()) {
        return it->second.category;
    }
    return std::nullopt;
}

References data_, and mutex_.

Referenced by kcenon::logger::scoped_context_guard::~scoped_context_guard().

Here is the caller graph for this function:

get_string()

std::string kcenon::logger::unified_log_context::get_string ( std::string_view key, std::string_view default_value = "" ) const

nodiscard

Get a context value as string.

Parameters

key	Field name
default_value	Value to return if not found

Returns

String value or default

Returns the value if it's a string, or the default value if not found or if the value is not a string type.

Definition at line 104 of file unified_log_context.cpp.

                                                                                {
    auto value = get(key);
    if (!value) {
        return std::string(default_value);
    }
    if (auto* str = std::get_if<std::string>(&*value)) {
        return *str;
    }
    return std::string(default_value);
}

References get().

Here is the call graph for this function:

has()

bool kcenon::logger::unified_log_context::has ( std::string_view key ) const

nodiscard

Check if a key exists in the context.

Parameters

key	Field name

Returns

true if key exists

Definition at line 129 of file unified_log_context.cpp.

                                                      {
    std::shared_lock lock(mutex_);
    return data_.find(std::string(key)) != data_.end();
}

References data_, and mutex_.

keys() [1/2]

std::vector< std::string > kcenon::logger::unified_log_context::keys ( ) const

nodiscard

Get all keys in the context.

Returns

Vector of key names

Definition at line 144 of file unified_log_context.cpp.

                                                     {
    std::shared_lock lock(mutex_);
    std::vector<std::string> result;
    result.reserve(data_.size());
    for (const auto& [key, _] : data_) {
        result.push_back(key);
    }
    return result;
}

References data_, and mutex_.

Referenced by kcenon::logger::scoped_context_guard::~scoped_context_guard().

Here is the caller graph for this function:

keys() [2/2]

std::vector< std::string > kcenon::logger::unified_log_context::keys ( context_category category ) const

nodiscard

Get keys for a specific category.

Parameters

category

Category to filter by

Returns

Vector of key names in the specified category

Definition at line 154 of file unified_log_context.cpp.

                                                                              {
    std::shared_lock lock(mutex_);
    std::vector<std::string> result;
    for (const auto& [key, entry] : data_) {
        if (entry.category == category) {
            result.push_back(key);
        }
    }
    return result;
}

References kcenon::logger::unified_log_context::entry::category, data_, and mutex_.

merge()

unified_log_context & kcenon::logger::unified_log_context::merge	(	const unified_log_context &	other,
		bool	overwrite = true )

Merge another context into this one.

Parameters

other	Context to merge from
overwrite	If true, other's values overwrite existing keys

Returns

Reference to this context for chaining

Copies all entries from other into this context. If overwrite is true (default), existing keys are replaced. If overwrite is false, existing keys are preserved.

Definition at line 218 of file unified_log_context.cpp.

                                                                                                {
    std::scoped_lock lock(mutex_, other.mutex_);
    for (const auto& [key, entry] : other.data_) {
        if (overwrite || data_.find(key) == data_.end()) {
            data_[key] = entry;
        }
    }
    return *this;
}

References data_, and mutex_.

operator=() [1/2]

unified_log_context & kcenon::logger::unified_log_context::operator=

(

const unified_log_context &

other

)

Copy assignment operator.

Parameters

other

Context to copy from

Returns

Reference to this context

Definition at line 22 of file unified_log_context.cpp.

                                                                                    {
    if (this != &other) {
        std::scoped_lock lock(mutex_, other.mutex_);
        data_ = other.data_;
    }
    return *this;
}

References data_, and mutex_.

operator=() [2/2]

unified_log_context & kcenon::logger::unified_log_context::operator= ( unified_log_context && other )

noexcept

Move assignment operator.

Parameters

other

Context to move from

Returns

Reference to this context

Definition at line 30 of file unified_log_context.cpp.

                                                                                        {
    if (this != &other) {
        std::scoped_lock lock(mutex_, other.mutex_);
        data_ = std::move(other.data_);
    }
    return *this;
}

remove()

void kcenon::logger::unified_log_context::remove

(

std::string_view

key

)

Remove a specific key from the context.

Parameters

key	Field name to remove

Definition at line 169 of file unified_log_context.cpp.

                                                   {
    std::unique_lock lock(mutex_);
    data_.erase(std::string(key));
}

References data_, and mutex_.

Referenced by kcenon::logger::log_context_scope::remove_logger_context().

Here is the caller graph for this function:

set()

unified_log_context & kcenon::logger::unified_log_context::set	(	std::string_view	key,
		context_value	value,
		context_category	category = context_category::custom )

Set a context value.

Parameters

key	Field name
value	Field value
category	Context category (default: custom)

Returns

Reference to this context for chaining

Sets a key-value pair in the context. If the key already exists, its value and category are updated.

Definition at line 42 of file unified_log_context.cpp.

                                                                         {
    std::unique_lock lock(mutex_);
    data_[std::string(key)] = entry{std::move(value), category};
    return *this;
}

References data_, and mutex_.

Referenced by kcenon::logger::log_context_scope::log_context_scope(), and kcenon::logger::scoped_context_guard::set().

Here is the caller graph for this function:

set_otel()

unified_log_context & kcenon::logger::unified_log_context::set_otel

(

const otlp::otel_context &

ctx

)

Set OpenTelemetry context.

Parameters

ctx	OpenTelemetry context structure

Returns

Reference to this context for chaining

Imports all fields from an otel_context structure with context_category::otel.

Definition at line 74 of file unified_log_context.cpp.

                                                                              {
    std::unique_lock lock(mutex_);
    if (!ctx.trace_id.empty()) {
        data_["otel_trace_id"] = entry{ctx.trace_id, context_category::otel};
    }
    if (!ctx.span_id.empty()) {
        data_["otel_span_id"] = entry{ctx.span_id, context_category::otel};
    }
    if (!ctx.trace_flags.empty()) {
        data_["otel_trace_flags"] = entry{ctx.trace_flags, context_category::otel};
    }
    if (!ctx.trace_state.empty()) {
        data_["otel_trace_state"] = entry{ctx.trace_state, context_category::otel};
    }
    return *this;
}

References data_, mutex_, kcenon::logger::otel, kcenon::logger::otlp::otel_context::span_id, kcenon::logger::otlp::otel_context::trace_flags, kcenon::logger::otlp::otel_context::trace_id, and kcenon::logger::otlp::otel_context::trace_state.

Referenced by kcenon::logger::scoped_context_guard::set_otel().

Here is the caller graph for this function:

set_request()

unified_log_context & kcenon::logger::unified_log_context::set_request	(	std::string_view	request_id,
		std::optional< std::string_view >	correlation_id = std::nullopt )

Set request context.

Parameters

request_id	Request identifier
correlation_id	Optional correlation identifier

Returns

Reference to this context for chaining

Sets request_id and optionally correlation_id with context_category::request. These are used for request tracking.

Definition at line 63 of file unified_log_context.cpp.

                                                {
    std::unique_lock lock(mutex_);
    data_["request_id"] = entry{std::string(request_id), context_category::request};
    if (correlation_id) {
        data_["correlation_id"] = entry{std::string(*correlation_id), context_category::request};
    }
    return *this;
}

References data_, mutex_, and kcenon::logger::request.

Referenced by kcenon::logger::scoped_context_guard::set_request().

Here is the caller graph for this function:

set_trace()

unified_log_context & kcenon::logger::unified_log_context::set_trace	(	std::string_view	trace_id,
		std::string_view	span_id,
		std::optional< std::string_view >	parent_span_id = std::nullopt )

Set trace context.

Parameters

trace_id	Trace identifier (32 hex chars)
span_id	Span identifier (16 hex chars)
parent_span_id	Optional parent span identifier

Returns

Reference to this context for chaining

Sets trace_id, span_id, and optionally parent_span_id with context_category::trace. These are used for distributed tracing.

Definition at line 50 of file unified_log_context.cpp.

                                                {
    std::unique_lock lock(mutex_);
    data_["trace_id"] = entry{std::string(trace_id), context_category::trace};
    data_["span_id"] = entry{std::string(span_id), context_category::trace};
    if (parent_span_id) {
        data_["parent_span_id"] = entry{std::string(*parent_span_id), context_category::trace};
    }
    return *this;
}

References data_, mutex_, and kcenon::logger::trace.

Referenced by kcenon::logger::scoped_context_guard::set_trace().

Here is the caller graph for this function:

size()

size_t kcenon::logger::unified_log_context::size ( ) const

nodiscard

Get the number of entries.

Returns

Number of context entries

Definition at line 139 of file unified_log_context.cpp.

                                       {
    std::shared_lock lock(mutex_);
    return data_.size();
}

References data_, and mutex_.

to_fields()

log_fields kcenon::logger::unified_log_context::to_fields ( ) const

nodiscard

Export context to log_fields format.

Returns

Map of string keys to log_value variants

Converts all context entries to the log_fields format used by the structured logging system. Values are converted as follows:

• std::monostate -> (key is skipped)
• bool -> bool
• int64_t -> int64_t
• double -> double
• std::string -> std::string

Definition at line 194 of file unified_log_context.cpp.

                                                {
    std::shared_lock lock(mutex_);
    log_fields result;
    for (const auto& [key, entry] : data_) {
        std::visit(
            [&result, &key](const auto& val) {
                using T = std::decay_t<decltype(val)>;
                if constexpr (std::is_same_v<T, std::monostate>) {
                    // Skip null values
                } else if constexpr (std::is_same_v<T, bool>) {
                    result[key] = val;
                } else if constexpr (std::is_same_v<T, int64_t>) {
                    result[key] = val;
                } else if constexpr (std::is_same_v<T, double>) {
                    result[key] = val;
                } else if constexpr (std::is_same_v<T, std::string>) {
                    result[key] = val;
                }
            },
            entry.value);
    }
    return result;
}

References data_, mutex_, and kcenon::logger::unified_log_context::entry::value.

Member Data Documentation

data_

std::unordered_map<std::string, entry> kcenon::logger::unified_log_context::data_

private

Definition at line 362 of file unified_log_context.h.

Referenced by clear(), clear(), empty(), get(), get_category(), has(), keys(), keys(), merge(), operator=(), remove(), set(), set_otel(), set_request(), set_trace(), size(), to_fields(), and unified_log_context().

mutex_

std::shared_mutex kcenon::logger::unified_log_context::mutex_

mutableprivate

Definition at line 361 of file unified_log_context.h.

Referenced by clear(), clear(), empty(), get(), get_category(), has(), keys(), keys(), merge(), operator=(), remove(), set(), set_otel(), set_request(), set_trace(), size(), to_fields(), and unified_log_context().

---

The documentation for this class was generated from the following files:

• include/kcenon/logger/core/unified_log_context.h
• src/core/unified_log_context.cpp