Logger.h#

// Copyright (c) 2018-2025, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//

#pragma once

#include "../Defines.h"

#include "ILogging.h"
#include "../thread/Types.h"

#include <cstdint>

namespace carb
{
namespace logging
{

#if CARB_VERSION_ATLEAST(carb_logging_ILogging, 1, 3) || defined(OMNI_BIND)
struct LogMessage
{
    size_t sizeOf{ sizeof(LogMessage) };

    const char* source;

    const char* fileName;

    int lineNumber;

    int32_t level;

    const char* moduleName;

    const char* functionName;

    process::ProcessId processId;

    thread::ThreadId threadId;

    const char* traceParentId;

    uint64_t timestampNs;

    const char* message;

    const char* globalExtraFields;

    const char* threadExtraFields;

    // Additional fields must be added here; no fields may be removed!
};
// These ABI parameters are guaranteed
static_assert(sizeof(LogMessage) >= 80 && alignof(LogMessage) == sizeof(size_t));
static_assert(offsetof(LogMessage, sizeOf) == 0);
static_assert(offsetof(LogMessage, source) == 8);
static_assert(offsetof(LogMessage, fileName) == 16);
static_assert(offsetof(LogMessage, lineNumber) == 24);
static_assert(offsetof(LogMessage, level) == 28);
static_assert(offsetof(LogMessage, moduleName) == 32);
static_assert(offsetof(LogMessage, functionName) == 40);
static_assert(offsetof(LogMessage, processId) == 48);
static_assert(offsetof(LogMessage, threadId) == 52);
static_assert(offsetof(LogMessage, traceParentId) == 56);
static_assert(offsetof(LogMessage, timestampNs) == 64);
static_assert(offsetof(LogMessage, message) == 72);
static_assert(offsetof(LogMessage, globalExtraFields) == 80);
static_assert(offsetof(LogMessage, threadExtraFields) == 88);

struct Logger2
{
    virtual void handleMessage(const LogMessage& message) = 0;
};
#else // Leave these types opaque
struct LogMessage;
struct Logger2;
#endif

struct Logger
{
    void(CARB_ABI* handleMessage)(Logger* logger,
                                  const char* source,
                                  int32_t level,
                                  const char* fileName,
                                  const char* functionName,
                                  int lineNumber,
                                  const char* message);

    // NOTE: This interface, because it is inherited from, is CLOSED and may not have any additional functions added
    // without an ILogging major version increase.
};

} // namespace logging
} // namespace carb