StructuredLog.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Concepts/Insertable.h"
#include "Containers/StringFwd.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Logging/LogVerbosity.h"
#include "Misc/OptionalFwd.h"
#include "Serialization/CompactBinary.h"
#include "Serialization/CompactBinaryWriter.h"
#include "Templates/IsArrayOrRefOfType.h"
#include "Templates/Models.h"
#include "Templates/Requires.h"
#include "Templates/UnrealTypeTraits.h"
 
#include <atomic>
#include <type_traits>
 
class FTextFormat;
template <typename FuncType> class TFunctionRef;
 
#define UE_API CORE_API
 
#define UE_LOGFMT(CategoryName, Verbosity, Format, ...) UE_PRIVATE_LOGFMT_CALL(UE_LOGFMT_EX, (CategoryName, Verbosity, Format UE_PRIVATE_LOGFMT_FIELDS(__VA_ARGS__)))
 
#define UE_CLOGFMT(Condition, CategoryName, Verbosity, Format, ...) UE_PRIVATE_LOGFMT_CALL(UE_CLOGFMT_EX, (Condition, CategoryName, Verbosity, Format UE_PRIVATE_LOGFMT_FIELDS(__VA_ARGS__)))
 
#define UE_LOGFMT_EX(CategoryName, Verbosity, Format, ...) UE_PRIVATE_LOGFMT(UE_EMPTY, CategoryName, Verbosity, Format, ##__VA_ARGS__)
 
#define UE_CLOGFMT_EX(Condition, CategoryName, Verbosity, Format, ...) UE_PRIVATE_LOGFMT(if (Condition), CategoryName, Verbosity, Format, ##__VA_ARGS__)
 
#define UE_LOGFMT_LOC(CategoryName, Verbosity, Key, Format, ...) \
    UE_LOGFMT_NSLOC(CategoryName, Verbosity, LOCTEXT_NAMESPACE, Key, Format, ##__VA_ARGS__)
#define UE_LOGFMT_NSLOC(CategoryName, Verbosity, Namespace, Key, Format, ...) \
    UE_PRIVATE_LOGFMT_CALL(UE_LOGFMT_NSLOC_EX, (CategoryName, Verbosity, Namespace, Key, Format UE_PRIVATE_LOGFMT_FIELDS(__VA_ARGS__)))
 
#define UE_CLOGFMT_LOC(Condition, CategoryName, Verbosity, Key, Format, ...) \
    UE_CLOGFMT_NSLOC(Condition, CategoryName, Verbosity, LOCTEXT_NAMESPACE, Key, Format, ##__VA_ARGS__)
#define UE_CLOGFMT_NSLOC(Condition, CategoryName, Verbosity, Namespace, Key, Format, ...) \
    UE_PRIVATE_LOGFMT_CALL(UE_CLOGFMT_NSLOC_EX, (Condition, CategoryName, Verbosity, Namespace, Key, Format UE_PRIVATE_LOGFMT_FIELDS(__VA_ARGS__)))
 
#define UE_LOGFMT_LOC_EX(CategoryName, Verbosity, Key, Format, ...) \
    UE_LOGFMT_NSLOC_EX(CategoryName, Verbosity, LOCTEXT_NAMESPACE, Key, Format, ##__VA_ARGS__)
#define UE_LOGFMT_NSLOC_EX(CategoryName, Verbosity, Namespace, Key, Format, ...) \
    UE_PRIVATE_LOGFMT_LOC(UE_EMPTY, CategoryName, Verbosity, Namespace, Key, Format, ##__VA_ARGS__)
 
#define UE_CLOGFMT_LOC_EX(Condition, CategoryName, Verbosity, Key, Format, ...) \
    UE_CLOGFMT_NSLOC_EX(Condition, CategoryName, Verbosity, LOCTEXT_NAMESPACE, Key, Format, ##__VA_ARGS__)
#define UE_CLOGFMT_NSLOC_EX(Condition, CategoryName, Verbosity, Namespace, Key, Format, ...) \
    UE_PRIVATE_LOGFMT_LOC(if (Condition), CategoryName, Verbosity, Namespace, Key, Format, ##__VA_ARGS__)
 
#define UE_LOGFMT_FIELD(Name, Value) UE_PRIVATE_LOGFMT_FIELD((Name, Value))
 
#define UE_LOGFMT_VALUE(Value) Value
 
#if !NO_LOGGING
 
#define UE_LOG_CONTEXT(Name, ...) ::UE::Logging::Private::FLogContext ANONYMOUS_VARIABLE(LogContext_)(Name, ##__VA_ARGS__)
 
#else // #if !NO_LOGGING
 
#define UE_LOG_CONTEXT(...)
 
#endif
 
struct FDateTime;
 
namespace UE
{
 
class FLogTemplate;
 
class FLogTime
{
public:
    UE_API static FLogTime Now();
    UE_API static FLogTime FromUtcTime(const FDateTime& UtcTime);
 
    constexpr FLogTime() = default;
 
    UE_API FDateTime GetUtcTime() const;
 
private:
    int64 UtcTicks = 0;
};
 
class FLogRecord
{
public:
    const FName& GetCategory() const { return Category; }
    void SetCategory(const FName& InCategory) { Category = InCategory; }
 
    ELogVerbosity::Type GetVerbosity() const { return Verbosity; }
    void SetVerbosity(ELogVerbosity::Type InVerbosity) { Verbosity = InVerbosity; }
 
    const FLogTime& GetTime() const { return Time; }
    void SetTime(const FLogTime& InTime) { Time = InTime; }
 
    const TCHAR* GetFormat() const { return Format; }
    void SetFormat(const TCHAR* InFormat) { Format = InFormat; }
 
    const FLogTemplate* GetTemplate() const { return Template; }
    void SetTemplate(const FLogTemplate* InTemplate) { Template = InTemplate; }
 
    const FCbObject& GetFields() const { return Fields; }
    void SetFields(FCbObject&& InFields) { Fields = MoveTemp(InFields); }
 
    const ANSICHAR* GetFile() const { return File; }
    void SetFile(const ANSICHAR* InFile) { File = InFile; }
 
    int32 GetLine() const { return Line; }
    void SetLine(int32 InLine) { Line = InLine; }
 
    const TCHAR* GetTextNamespace() const { return TextNamespace; }
    void SetTextNamespace(const TCHAR* InTextNamespace) { TextNamespace = InTextNamespace; }
 
    const TCHAR* GetTextKey() const { return TextKey; }
    void SetTextKey(const TCHAR* InTextKey) { TextKey = InTextKey; }
 
    UE_API void FormatMessageTo(FUtf8StringBuilderBase& Out) const;
    UE_API void FormatMessageTo(FWideStringBuilderBase& Out) const;
 
    UE_API void ConvertToCommonLog(FUtf8StringBuilderBase& OutFormat, FCbWriter& OutFields) const;
 
private:
    const TCHAR* Format = nullptr;
    const ANSICHAR* File = nullptr;
    int32 Line = 0;
    FName Category;
    ELogVerbosity::Type Verbosity = ELogVerbosity::Log;
    FLogTime Time;
    FCbObject Fields;
    const FLogTemplate* Template = nullptr;
    const TCHAR* TextNamespace = nullptr;
    const TCHAR* TextKey = nullptr;
};
 
UE_API void DispatchDynamicLogRecord(const FLogRecord& Record);
 
UE_API void VisitLogContext(TFunctionRef<void (const FCbField&)> Visitor);
 
template <typename ValueType UE_REQUIRES(TModels_V<CInsertable<FCbWriter&>, ValueType>)>
inline void SerializeForLog(FCbWriter& Writer, ValueType&& Value)
{
    Writer << (ValueType&&)Value;
}
 
struct CSerializableForLog
{
    template <typename ValueType>
    auto Requires(FCbWriter& Writer, ValueType&& Value) -> decltype(
        SerializeForLog(Writer, (ValueType&&)Value)
    );
};
 
template <typename ValueType UE_REQUIRES(TModels_V<CSerializableForLog, ValueType>)>
inline void CallSerializeForLog(FCbWriter& Writer, ValueType&& Value)
{
    SerializeForLog(Writer, (ValueType&&)Value);
}
 
} // UE
 
template <typename ValueType UE_REQUIRES(TModels_V<UE::CSerializableForLog, ValueType>)>
inline void SerializeForLog(FCbWriter& Writer, const TOptional<ValueType>& Optional)
{
    Writer.BeginArray();
    if (Optional)
    {
        UE::CallSerializeForLog(Writer, Optional.GetValue());
    }
    Writer.EndArray();
}
 
namespace UE::Logging::Private
{
 
struct FStaticLogDynamicData
{
    std::atomic<FLogTemplate*> Template = nullptr;
#if LOGTRACE_ENABLED
    std::atomic<bool> bInitializedTrace = false;
#endif
};
 
struct FStaticLogRecord
{
    const TCHAR* Format = nullptr;
    UE_IF(UE_LOG_INCLUDE_SOURCE_LOCATION,, inline static constexpr) const ANSICHAR* File = nullptr;
    UE_IF(UE_LOG_INCLUDE_SOURCE_LOCATION,, inline static constexpr) int32 Line = 0;
    ELogVerbosity::Type Verbosity = ELogVerbosity::Log;
    FStaticLogDynamicData& DynamicData;
 
    // Workaround for https://developercommunity.visualstudio.com/t/Incorrect-warning-C4700-with-unrelated-s/10285950
    constexpr FStaticLogRecord(
        const TCHAR* InFormat,
        const ANSICHAR* InFile,
        int32 InLine,
        ELogVerbosity::Type InVerbosity,
        FStaticLogDynamicData& InDynamicData)
        : Format(InFormat)
    #if UE_LOG_INCLUDE_SOURCE_LOCATION
        , File(InFile)
        , Line(InLine)
    #endif
        , Verbosity(InVerbosity)
        , DynamicData(InDynamicData)
    {
    }
};
 
struct FStaticLocalizedLogRecord
{
    const TCHAR* TextNamespace = nullptr;
    const TCHAR* TextKey = nullptr;
    const TCHAR* Format = nullptr;
    UE_IF(UE_LOG_INCLUDE_SOURCE_LOCATION,, inline static constexpr) const ANSICHAR* File = nullptr;
    UE_IF(UE_LOG_INCLUDE_SOURCE_LOCATION,, inline static constexpr) int32 Line = 0;
    ELogVerbosity::Type Verbosity = ELogVerbosity::Log;
    FStaticLogDynamicData& DynamicData;
 
    // Workaround for https://developercommunity.visualstudio.com/t/Incorrect-warning-C4700-with-unrelated-s/10285950
    constexpr FStaticLocalizedLogRecord(
        const TCHAR* InTextNamespace,
        const TCHAR* InTextKey,
        const TCHAR* InFormat,
        const ANSICHAR* InFile,
        int32 InLine,
        ELogVerbosity::Type InVerbosity,
        FStaticLogDynamicData& InDynamicData)
        : TextNamespace(InTextNamespace)
        , TextKey(InTextKey)
        , Format(InFormat)
    #if UE_LOG_INCLUDE_SOURCE_LOCATION
        , File(InFile)
        , Line(InLine)
    #endif
        , Verbosity(InVerbosity)
        , DynamicData(InDynamicData)
    {
    }
};
 
struct FLogField
{
    using FWriteFn = void (FCbWriter& Writer, const void* Value);
 
    const ANSICHAR* Name;
    const void* Value;
    FWriteFn* WriteValue;
 
    template <typename ValueType>
    static void Write(FCbWriter& Writer, const void* Value)
    {
        SerializeForLog(Writer, *(const ValueType*)Value);
    }
};
 
#if !NO_LOGGING
UE_API void LogWithNoFields(const FLogCategoryBase& Category, const FStaticLogRecord& Log);
UE_API void LogWithFieldArray(const FLogCategoryBase& Category, const FStaticLogRecord& Log, const FLogField* Fields, int32 FieldCount);
UE_API void LogWithNoFields(const FLogCategoryBase& Category, const FStaticLocalizedLogRecord& Log);
UE_API void LogWithFieldArray(const FLogCategoryBase& Category, const FStaticLocalizedLogRecord& Log, const FLogField* Fields, int32 FieldCount);
#endif
 
[[noreturn]] UE_API void FatalLogWithNoFields(const FLogCategoryBase& Category, const FStaticLogRecord& Log);
[[noreturn]] UE_API void FatalLogWithFieldArray(const FLogCategoryBase& Category, const FStaticLogRecord& Log, const FLogField* Fields, int32 FieldCount);
[[noreturn]] UE_API void FatalLogWithNoFields(const FLogCategoryBase& Category, const FStaticLocalizedLogRecord& Log);
[[noreturn]] UE_API void FatalLogWithFieldArray(const FLogCategoryBase& Category, const FStaticLocalizedLogRecord& Log, const FLogField* Fields, int32 FieldCount);
 
template <typename NameType>
struct TLogFieldName
{
    NameType Name;
};
 
template <typename NameType>
inline constexpr TLogFieldName<NameType> CheckFieldName(NameType&& Name)
{
    static_assert(TIsArrayOrRefOfType<NameType, ANSICHAR>::Value, "Name must be an ANSICHAR string literal.");
    return {(NameType&&)Name};
}
 
struct FLogFieldCreator
{
    template <typename T> inline constexpr static int32 ValueCount = 1;
    template <typename T> inline constexpr static int32 ValueCount<TLogFieldName<T>> = 0;
 
    template <typename... FieldArgTypes>
    inline constexpr static int32 GetCount()
    {
        return (ValueCount<FieldArgTypes> + ...);
    }
 
    inline static void Create(FLogField* Fields)
    {
    }
 
    template <typename ValueType, typename... FieldArgTypes, std::enable_if_t<ValueCount<ValueType>>* = nullptr>
    inline static void Create(FLogField* Fields, const ValueType& Value, FieldArgTypes&&... FieldArgs)
    {
        new(Fields) FLogField{nullptr, &Value, FLogField::Write<ValueType>};
        Create(Fields + 1, (FieldArgTypes&&)FieldArgs...);
    }
 
    template <typename NameType, typename ValueType, typename... FieldArgTypes>
    inline static void Create(FLogField* Fields, TLogFieldName<NameType> Name, const ValueType& Value, FieldArgTypes&&... FieldArgs)
    {
        new(Fields) FLogField{Name.Name, &Value, FLogField::Write<ValueType>};
        Create(Fields + 1, (FieldArgTypes&&)FieldArgs...);
    }
};
 
template <typename LogType, typename... FieldArgTypes>
UE_COLD UE_DEBUG_SECTION void LogWithFields(const FLogCategoryBase& Category, const LogType& Log, FieldArgTypes&&... FieldArgs)
{
    if constexpr (sizeof...(FieldArgTypes) == 0)
    {
        LogWithNoFields(Category, Log);
    }
    else
    {
        constexpr int32 FieldCount = FLogFieldCreator::template GetCount<FieldArgTypes...>();
        static_assert(FieldCount > 0);
        FLogField Fields[FieldCount];
        FLogFieldCreator::Create(Fields, (FieldArgTypes&&)FieldArgs...);
        LogWithFieldArray(Category, Log, Fields, FieldCount);
    }
}
 
template <typename LogType, typename... FieldArgTypes>
[[noreturn]] UE_COLD UE_DEBUG_SECTION void FatalLogWithFields(const FLogCategoryBase& Category, const LogType& Log, FieldArgTypes&&... FieldArgs)
{
    if constexpr (sizeof...(FieldArgTypes) == 0)
    {
        FatalLogWithNoFields(Category, Log);
    }
    else
    {
        constexpr int32 FieldCount = FLogFieldCreator::template GetCount<FieldArgTypes...>();
        static_assert(FieldCount > 0);
        FLogField Fields[FieldCount];
        FLogFieldCreator::Create(Fields, (FieldArgTypes&&)FieldArgs...);
        FatalLogWithFieldArray(Category, Log, Fields, FieldCount);
    }
}
 
#if NO_LOGGING
UE_API extern FLogCategory<ELogVerbosity::Fatal, ELogVerbosity::Fatal> LogFatal;
#endif
 
struct FLogContext
{
    inline explicit FLogContext(const ANSICHAR* Name)
        : FLogContext({Name, nullptr, nullptr})
    {
    }
 
    template <typename ValueType>
    inline explicit FLogContext(const ANSICHAR* Name, const ValueType& Value)
        : FLogContext({Name, &Value, FLogField::Write<ValueType>})
    {
    }
 
    UE_API explicit FLogContext(const FLogField& Field);
    UE_API ~FLogContext();
 
    FLogContext(const FLogContext&) = delete;
    FLogContext& operator=(const FLogContext&) = delete;
 
    FCbField Field;
    FLogContext* Next = nullptr;
    FLogContext* Prev = nullptr;
    bool bDisabledByNewerContext = false;
    bool bDisabledOlderContext = false;
};
 
} // UE::Logging::Private
 
#if !NO_LOGGING
#define UE_PRIVATE_LOG_CATEGORY(CategoryName) CategoryName
#else
#define UE_PRIVATE_LOG_CATEGORY(CategoryName) ::UE::Logging::Private::LogFatal
#endif
 
#define UE_PRIVATE_LOGFMT(Condition, CategoryName, Verbosity, Format, ...) \
    do \
    { \
        if constexpr ((::ELogVerbosity::Verbosity & ::ELogVerbosity::VerbosityMask) == ::ELogVerbosity::Fatal || \
            ((::ELogVerbosity::Verbosity & ::ELogVerbosity::VerbosityMask) <= ::ELogVerbosity::COMPILED_IN_MINIMUM_VERBOSITY && \
             (::ELogVerbosity::Verbosity & ::ELogVerbosity::VerbosityMask) <= UE_PRIVATE_LOG_CATEGORY(CategoryName).CompileTimeVerbosity)) \
        { \
            static ::UE::Logging::Private::FStaticLogDynamicData LOG_Dynamic; \
            static constexpr ::UE::Logging::Private::FStaticLogRecord LOG_Static UE_PRIVATE_LOGFMT_AGGREGATE(TEXT(Format), __builtin_FILE(), __builtin_LINE(), ::ELogVerbosity::Verbosity, LOG_Dynamic); \
            UE_PRIVATE_LOGFMT_LOG_IF_ACTIVE(Condition, CategoryName, Verbosity, LOG_Static, ##__VA_ARGS__); \
        } \
    } \
    while (false)
 
#define UE_PRIVATE_LOGFMT_LOC(Condition, CategoryName, Verbosity, Namespace, Key, Format, ...) \
    do \
    { \
        if constexpr ((::ELogVerbosity::Verbosity & ::ELogVerbosity::VerbosityMask) == ::ELogVerbosity::Fatal || \
            ((::ELogVerbosity::Verbosity & ::ELogVerbosity::VerbosityMask) <= ::ELogVerbosity::COMPILED_IN_MINIMUM_VERBOSITY && \
             (::ELogVerbosity::Verbosity & ::ELogVerbosity::VerbosityMask) <= UE_PRIVATE_LOG_CATEGORY(CategoryName).CompileTimeVerbosity)) \
        { \
            static ::UE::Logging::Private::FStaticLogDynamicData LOG_Dynamic; \
            static constexpr ::UE::Logging::Private::FStaticLocalizedLogRecord LOG_Static UE_PRIVATE_LOGFMT_AGGREGATE(TEXT(Namespace), TEXT(Key), TEXT(Format), __builtin_FILE(), __builtin_LINE(), ::ELogVerbosity::Verbosity, LOG_Dynamic); \
            UE_PRIVATE_LOGFMT_LOG_IF_ACTIVE(Condition, CategoryName, Verbosity, LOG_Static, ##__VA_ARGS__); \
        } \
    } \
    while (false)
 
#define UE_PRIVATE_LOGFMT_LOG_IF_ACTIVE(Condition, CategoryName, Verbosity, Log, ...) \
    if constexpr ((::ELogVerbosity::Verbosity & ::ELogVerbosity::VerbosityMask) == ::ELogVerbosity::Fatal) \
    { \
        Condition \
        { \
            ::UE::Logging::Private::FatalLogWithFields(UE_PRIVATE_LOG_CATEGORY(CategoryName), LOG_Static, ##__VA_ARGS__); \
        } \
    } \
    else if (!UE_PRIVATE_LOG_CATEGORY(CategoryName).IsSuppressed(::ELogVerbosity::Verbosity)) \
    { \
        Condition \
        { \
            ::UE::Logging::Private::LogWithFields(UE_PRIVATE_LOG_CATEGORY(CategoryName), LOG_Static, ##__VA_ARGS__); \
        } \
    }
 
// This macro avoids having non-parenthesized commas in the log macros.
// Such commas can cause issues when a log macro is wrapped by another macro.
#define UE_PRIVATE_LOGFMT_AGGREGATE(...) {__VA_ARGS__}
 
// This macro expands a field from either `(Name, Value)` or `Value`
// A `(Name, Value)` field is converted to `CheckFieldName(Name), Value`
// A `Value` field is passed through as `Value`
#define UE_PRIVATE_LOGFMT_FIELD(Field) UE_PRIVATE_LOGFMT_FIELD_EXPAND(UE_PRIVATE_LOGFMT_NAMED_FIELD Field)
// This macro is only called when the field was parenthesized.
#define UE_PRIVATE_LOGFMT_NAMED_FIELD(Name, ...) UE_PRIVATE_LOGFMT_NAMED_FIELD ::UE::Logging::Private::CheckFieldName(Name), __VA_ARGS__
// The next three macros remove UE_PRIVATE_LOGFMT_NAMED_FIELD from the expanded expression.
#define UE_PRIVATE_LOGFMT_FIELD_EXPAND(...) UE_PRIVATE_LOGFMT_FIELD_EXPAND_INNER(__VA_ARGS__)
#define UE_PRIVATE_LOGFMT_FIELD_EXPAND_INNER(...) UE_PRIVATE_LOGFMT_STRIP_ ## __VA_ARGS__
#define UE_PRIVATE_LOGFMT_STRIP_UE_PRIVATE_LOGFMT_NAMED_FIELD
 
// This macro expands `Arg1, Arg2` to `UE_PRIVATE_LOGFMT_FIELD(Arg1), UE_PRIVATE_LOGFMT_FIELD(Arg2), ...`
// This macro expands `("Name1", Arg1), ("Name2", Arg2)` to `UE_PRIVATE_LOGFMT_FIELD(("Name1", Arg1)), UE_PRIVATE_LOGFMT_FIELD(("Name2", Arg2)), ...
#define UE_PRIVATE_LOGFMT_FIELDS(...) UE_PRIVATE_LOGFMT_CALL(UE_JOIN(UE_PRIVATE_LOGFMT_FIELDS_, UE_PRIVATE_LOGFMT_COUNT(__VA_ARGS__)), (__VA_ARGS__))
 
#define UE_PRIVATE_LOGFMT_FIELDS_0()
#define UE_PRIVATE_LOGFMT_FIELDS_1(A)                 , UE_PRIVATE_LOGFMT_FIELD(A)
#define UE_PRIVATE_LOGFMT_FIELDS_2(A,B)               , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B)
#define UE_PRIVATE_LOGFMT_FIELDS_3(A,B,C)             , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C)
#define UE_PRIVATE_LOGFMT_FIELDS_4(A,B,C,D)           , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D)
#define UE_PRIVATE_LOGFMT_FIELDS_5(A,B,C,D,E)         , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E)
#define UE_PRIVATE_LOGFMT_FIELDS_6(A,B,C,D,E,F)       , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F)
#define UE_PRIVATE_LOGFMT_FIELDS_7(A,B,C,D,E,F,G)     , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G)
#define UE_PRIVATE_LOGFMT_FIELDS_8(A,B,C,D,E,F,G,H)   , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G), UE_PRIVATE_LOGFMT_FIELD(H)
#define UE_PRIVATE_LOGFMT_FIELDS_9(A,B,C,D,E,F,G,H,I) , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G), UE_PRIVATE_LOGFMT_FIELD(H), UE_PRIVATE_LOGFMT_FIELD(I)
 
#define UE_PRIVATE_LOGFMT_FIELDS_10(A,B,C,D,E,F,G,H,I,J)             , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G), UE_PRIVATE_LOGFMT_FIELD(H), UE_PRIVATE_LOGFMT_FIELD(I), UE_PRIVATE_LOGFMT_FIELD(J)
#define UE_PRIVATE_LOGFMT_FIELDS_11(A,B,C,D,E,F,G,H,I,J,K)           , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G), UE_PRIVATE_LOGFMT_FIELD(H), UE_PRIVATE_LOGFMT_FIELD(I), UE_PRIVATE_LOGFMT_FIELD(J), UE_PRIVATE_LOGFMT_FIELD(K)
#define UE_PRIVATE_LOGFMT_FIELDS_12(A,B,C,D,E,F,G,H,I,J,K,L)         , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G), UE_PRIVATE_LOGFMT_FIELD(H), UE_PRIVATE_LOGFMT_FIELD(I), UE_PRIVATE_LOGFMT_FIELD(J), UE_PRIVATE_LOGFMT_FIELD(K), UE_PRIVATE_LOGFMT_FIELD(L)
#define UE_PRIVATE_LOGFMT_FIELDS_13(A,B,C,D,E,F,G,H,I,J,K,L,M)       , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G), UE_PRIVATE_LOGFMT_FIELD(H), UE_PRIVATE_LOGFMT_FIELD(I), UE_PRIVATE_LOGFMT_FIELD(J), UE_PRIVATE_LOGFMT_FIELD(K), UE_PRIVATE_LOGFMT_FIELD(L), UE_PRIVATE_LOGFMT_FIELD(M)
#define UE_PRIVATE_LOGFMT_FIELDS_14(A,B,C,D,E,F,G,H,I,J,K,L,M,N)     , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G), UE_PRIVATE_LOGFMT_FIELD(H), UE_PRIVATE_LOGFMT_FIELD(I), UE_PRIVATE_LOGFMT_FIELD(J), UE_PRIVATE_LOGFMT_FIELD(K), UE_PRIVATE_LOGFMT_FIELD(L), UE_PRIVATE_LOGFMT_FIELD(M), UE_PRIVATE_LOGFMT_FIELD(N)
#define UE_PRIVATE_LOGFMT_FIELDS_15(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O)   , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G), UE_PRIVATE_LOGFMT_FIELD(H), UE_PRIVATE_LOGFMT_FIELD(I), UE_PRIVATE_LOGFMT_FIELD(J), UE_PRIVATE_LOGFMT_FIELD(K), UE_PRIVATE_LOGFMT_FIELD(L), UE_PRIVATE_LOGFMT_FIELD(M), UE_PRIVATE_LOGFMT_FIELD(N), UE_PRIVATE_LOGFMT_FIELD(O)
#define UE_PRIVATE_LOGFMT_FIELDS_16(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) , UE_PRIVATE_LOGFMT_FIELD(A), UE_PRIVATE_LOGFMT_FIELD(B), UE_PRIVATE_LOGFMT_FIELD(C), UE_PRIVATE_LOGFMT_FIELD(D), UE_PRIVATE_LOGFMT_FIELD(E), UE_PRIVATE_LOGFMT_FIELD(F), UE_PRIVATE_LOGFMT_FIELD(G), UE_PRIVATE_LOGFMT_FIELD(H), UE_PRIVATE_LOGFMT_FIELD(I), UE_PRIVATE_LOGFMT_FIELD(J), UE_PRIVATE_LOGFMT_FIELD(K), UE_PRIVATE_LOGFMT_FIELD(L), UE_PRIVATE_LOGFMT_FIELD(M), UE_PRIVATE_LOGFMT_FIELD(N), UE_PRIVATE_LOGFMT_FIELD(O), UE_PRIVATE_LOGFMT_FIELD(P)
 
#define UE_PRIVATE_LOGFMT_COUNT(...) UE_PRIVATE_LOGFMT_CALL(UE_PRIVATE_LOGFMT_COUNT_IMPL, (_, ##__VA_ARGS__, 16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0))
#define UE_PRIVATE_LOGFMT_COUNT_IMPL(_, A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P, Count, ...) Count
 
#define UE_PRIVATE_LOGFMT_CALL(F, A) UE_PRIVATE_LOGFMT_EXPAND(F A)
#define UE_PRIVATE_LOGFMT_EXPAND(X) X
 
#undef UE_API