Program Listing for omni/structuredlog/StructuredLogSettingsUtils.h

↰ Return to documentation for omni/structuredlog/StructuredLogSettingsUtils.h

// Copyright (c) 2021, 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 "IStructuredLog.h"
#include "IStructuredLogSettings.h"
#include "IStructuredLogFromILog.h"

#include <carb/extras/StringSafe.h>
#include <carb/settings/ISettings.h>
#include <omni/extras/PrivacySettings.h>
#include <omni/log/ILog.h>


namespace omni
{
namespace structuredlog
{

constexpr int64_t kDefaultLogSizeLimit = 50ll * 1024ll * 1024ll;

constexpr int64_t kMinLogSizeLimit = 256ll * 1024ll;

constexpr size_t kDefaultLogRetentionCount = 3;

constexpr size_t kMinLogRetentionCount = 1;

constexpr size_t kDefaultEventQueueSize = 2 * 1024 * 1024;

constexpr size_t kMinEventQueueSize = 512 * 1024;

constexpr IdMode kDefaultIdMode = IdMode::eFastSequential;

constexpr IdType kDefaultIdType = IdType::eUuid;
constexpr const char* kGlobalEnableSetting = "/structuredLog/enable";

constexpr const char* kLogDirectory = "/structuredLog/logDirectory";

constexpr const char* kDefaultLogNameSetting = "/structuredLog/defaultLogName";

constexpr const char* kLogRetentionCountSetting = "/structuredLog/logRetentionCount";

constexpr const char* kLogSizeLimitSetting = "/structuredLog/logSizeLimit";

constexpr const char* kEventQueueSizeSetting = "/structuredLog/eventQueueSize";

constexpr const char* kEventIdModeSetting = "/structuredLog/eventIdMode";

constexpr const char* kEventIdTypeSetting = "/structuredLog/eventIdType";

constexpr const char* kEnableLogConsumerSetting = "/structuredLog/enableLogConsumer";

constexpr const char* kSchemasStateListSetting = "/structuredLog/state/schemas";

constexpr const char* kEventsStateListSetting = "/structuredLog/state/events";

constexpr const char* kSchemasStateArraySetting = "/structuredLog/schemaStates";

constexpr const char* kEventsStateArraySetting = "/structuredLog/eventStates";
inline bool setStructuredLogLoggingEnabled(bool enabled = true)
{
    omni::core::ObjectPtr<IStructuredLog> strucLog;
    omni::core::ObjectPtr<IStructuredLogFromILog> log;


    strucLog = omni::core::borrow(omniGetStructuredLogWithoutAcquire());

    if (strucLog.get() == nullptr)
        return false;

    log = strucLog.as<IStructuredLogFromILog>();

    if (log.get() == nullptr)
        return false;

    if (enabled)
        log->enableLogging();

    else
        log->disableLogging();

    return true;
}

inline void configureStructuredLogging(carb::settings::ISettings* settings)
{
    omni::core::ObjectPtr<IStructuredLog> strucLog;
    omni::core::ObjectPtr<IStructuredLogSettings> ts;
    omni::core::ObjectPtr<IStructuredLogFromILog> log;
    const char* value;
    int64_t count;
    IdMode idMode = kDefaultIdMode;
    IdType idType = kDefaultIdType;


    if (settings == nullptr)
        return;

    // ****** set appropriate defaults for each setting ******
    settings->setDefaultBool(kGlobalEnableSetting, false);
    settings->setDefaultString(kLogDirectory, "");
    settings->setDefaultString(kDefaultLogNameSetting, "");
    settings->setDefaultInt64(kLogRetentionCountSetting, kDefaultLogRetentionCount);
    settings->setDefaultInt64(kLogSizeLimitSetting, kDefaultLogSizeLimit / 1048576);
    settings->setDefaultInt64(kEventQueueSizeSetting, kDefaultEventQueueSize / 1024);
    settings->setDefaultString(kEventIdModeSetting, "fast-sequential");
    settings->setDefaultString(kEventIdTypeSetting, "UUID");
    settings->setDefaultBool(kEnableLogConsumerSetting, false);


    // ****** grab the structured log settings object so the config can be set ******
    strucLog = omni::core::borrow(omniGetStructuredLogWithoutAcquire());

    if (strucLog.get() == nullptr)
        return;

    ts = strucLog.as<IStructuredLogSettings>();

    if (ts.get() == nullptr)
        return;


    // ****** retrieve the settings and make them active ******
    strucLog->setEnabled(omni::structuredlog::kBadEventId, omni::structuredlog::fEnableFlagAll,
                         settings->getAsBool(kGlobalEnableSetting));

    // set the default log name.
    value = settings->getStringBuffer(kDefaultLogNameSetting);

    if (value != nullptr && value[0] != 0)
        ts->setLogDefaultName(value);

    value = settings->getStringBuffer(kLogDirectory);

    if (value != nullptr && value[0] != 0)
        ts->setLogOutputPath(value);

    // set the log retention count.
    count = settings->getAsInt64(kLogRetentionCountSetting);
    ts->setLogRetentionCount(count);

    // set the log size limit.
    count = settings->getAsInt64(kLogSizeLimitSetting);
    ts->setLogSizeLimit(count * 1048576);

    // set the event queue size.
    count = settings->getAsInt64(kEventQueueSizeSetting);
    ts->setEventQueueSize(count * 1024);

    // set the event ID mode.
    value = settings->getStringBuffer(kEventIdModeSetting);

    if (carb::extras::compareStringsNoCase(value, "fast-sequential") == 0)
        idMode = IdMode::eFastSequential;

    else if (carb::extras::compareStringsNoCase(value, "sequential") == 0)
        idMode = IdMode::eSequential;

    else if (carb::extras::compareStringsNoCase(value, "random") == 0)
        idMode = IdMode::eRandom;

    else
        OMNI_LOG_WARN("unknown event ID mode '%s'.  Assuming 'fast-sequential'.", value);

    // set the event ID type.
    value = settings->getStringBuffer(kEventIdTypeSetting);

    if (carb::extras::compareStringsNoCase(value, "UUID") == 0)
        idType = IdType::eUuid;

    else if (carb::extras::compareStringsNoCase(value, "uint64") == 0)
        idType = IdType::eUint64;

    else
        OMNI_LOG_WARN("unknown event ID type '%s'.  Assuming 'UUID'.", value);

    ts->setEventIdMode(idMode, idType);

    // load the privacy settings and set the user ID from it.
    ts->loadPrivacySettings();

    // load the enable states for each schema and event.
    ts->enableSchemasFromSettings();

    value = omni::extras::PrivacySettings::getUserId();

    if (value != nullptr && value[0] != 0)
        ts->setUserId(value);

    // setup the structured log logger.
    log = strucLog.as<IStructuredLogFromILog>();
    strucLog.release();

    if (log.get() == nullptr)
        return;

    if (settings->getAsBool(kEnableLogConsumerSetting))
        log->enableLogging();
}

} // namespace structuredlog
} // namespace omni