log_extra.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/logging/log_extra.hpp
/// @brief @copybrief logging::LogExtra
 
#include <initializer_list>
#include <string>
#include <utility>
#include <variant>
 
#include <boost/container/container_fwd.hpp>
 
#include <userver/compiler/select.hpp>
#include <userver/logging/fwd.hpp>
#include <userver/utils/fast_pimpl.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace tracing {
 
class TagScope;
 
class Span;
 
}  // namespace tracing
 
namespace logging {
 
class LogHelper;
 
namespace impl {
class TagWriter;
}  // namespace impl
 
/// Extra tskv fields storage
class LogExtra final {
public:
    using Value =
        std::variant<std::string, int, long, long long, unsigned int, unsigned long, unsigned long long, float, double>;
    using Key = std::string;
    using Pair = std::pair<Key, Value>;
 
    /// Specifies replacement policy for newly added values
    enum class ExtendType {
        kNormal,  ///< Added value can be replaced
        kFrozen,  ///< Attempts to replace this value will be ignored
    };
 
    LogExtra() noexcept;
 
    LogExtra(const LogExtra&);
 
    // NOLINTNEXTLINE(performance-noexcept-move-constructor)
    LogExtra(LogExtra&&);
 
    ~LogExtra();
 
    // NOLINTNEXTLINE(performance-noexcept-move-constructor)
    LogExtra& operator=(LogExtra&&);
 
    LogExtra& operator=(const LogExtra&);
 
    /// Constructs LogExtra containing an initial batch of key-value pairs
    LogExtra(std::initializer_list<Pair> initial, ExtendType extend_type = ExtendType::kNormal);
 
    /// Adds a single key-value pair
    void Extend(std::string key, Value value, ExtendType extend_type = ExtendType::kNormal);
 
    /// Adds a single key-value pair
    void Extend(Pair extra, ExtendType extend_type = ExtendType::kNormal);
 
    /// Adds a batch of key-value pairs
    void Extend(std::initializer_list<Pair> extra, ExtendType extend_type = ExtendType::kNormal);
 
    /// @brief Merges contents of other LogExtra with existing key-value pairs
    /// preserving freeze states
    void Extend(const LogExtra& extra);
 
    /// @brief Merges contents of other LogExtra with existing key-value pairs
    /// preserving freeze states
    void Extend(LogExtra&& extra);
 
    /// @brief Creates a LogExtra with current thread's stacktrace if the default
    /// log level is less or equal to DEBUG
    static LogExtra StacktraceNocache() noexcept;
 
    /// @brief Creates a LogExtra with current thread's stacktrace if the logger
    /// log level is less or equal to DEBUG
    static LogExtra StacktraceNocache(logging::LoggerRef logger) noexcept;
 
    /// @brief Creates a LogExtra with current thread's stacktrace if the logger
    /// log level is less or equal to DEBUG. Uses cache for
    /// faster stacktrace symbolization.
    static LogExtra Stacktrace() noexcept;
 
    /// @brief Creates a LogExtra with current thread's stacktrace if the logger
    /// log level is less or equal to DEBUG. Uses cache for
    /// faster stacktrace symbolization.
    static LogExtra Stacktrace(logging::LoggerRef logger) noexcept;
 
    /// @brief Adds a range of key-value pairs
    template <typename Iterator>
    void ExtendRange(Iterator first, Iterator last, ExtendType extend_type = ExtendType::kNormal) {
        // NOTE: must replace existing rewritable values
        for (Iterator it = first; it != last; ++it) Extend(*it, extend_type);
    }
 
    /// @brief Marks specified value as frozen, all attempts to overwrite it will
    /// be silently ignored.
    void SetFrozen(const std::string& key);
 
    friend class impl::TagWriter;
    friend class tracing::Span;
    friend class tracing::TagScope;
 
private:
    const Value& GetValue(std::string_view key) const;
 
    class ProtectedValue final {
    public:
        ProtectedValue() = default;
        ProtectedValue(Value value, bool frozen);
        ProtectedValue(const ProtectedValue& other) = default;
        ProtectedValue(ProtectedValue&& other) = default;
 
        ProtectedValue& operator=(const ProtectedValue& other);
        ProtectedValue& operator=(ProtectedValue&& other) noexcept;
 
        bool IsFrozen() const;
        void SetFrozen();
        Value& GetValue() { return value_; }
        const Value& GetValue() const { return value_; }
        void AssignIgnoringFrozenness(ProtectedValue other);
 
    private:
        Value value_;
        bool frozen_ = false;
    };
 
    static constexpr std::size_t kSmallVectorSize = 24;
    static constexpr std::size_t kPimplSize =
        compiler::SelectSize().ForLibCpp32(1168).ForLibCpp64(1560).ForLibStdCpp64(1944).ForLibStdCpp32(1356);
    using MapItem = std::pair<Key, ProtectedValue>;
    using Map = boost::container::small_vector<MapItem, kSmallVectorSize>;
 
    void Extend(std::string key, ProtectedValue protected_value, ExtendType extend_type = ExtendType::kNormal);
 
    void Extend(MapItem extra, ExtendType extend_type = ExtendType::kNormal);
 
    std::pair<Key, ProtectedValue>* Find(std::string_view);
 
    const std::pair<Key, ProtectedValue>* Find(std::string_view) const;
 
    utils::FastPimpl<Map, kPimplSize, alignof(void*)> extra_;
};
 
extern const LogExtra kEmptyLogExtra;
 
}  // namespace logging
 
USERVER_NAMESPACE_END