static void logger_init_once()

in src/logging/logging.cpp [125:252]

• 94 lines of code
• 32 McCabe index (conditional complexity)

static void logger_init_once(logger_global_context_t *global)
{
    // All other members are initialized to zero
    rwlock_init(&global->lock);

    global->env_log_level = K4A_LOG_LEVEL_OFF;
    global->user_log_level = K4A_LOG_LEVEL_OFF;

    const char *enable_file_logging = nullptr;
    const char *enable_stdout_logging = nullptr;
    const char *logging_level = nullptr;
    k4a_result_t result = K4A_RESULT_SUCCEEDED;

    // environment_get_variable will return null or "\0" if the env var is not set - depends on the OS.
    enable_file_logging = environment_get_variable(K4A_ENV_VAR_LOG_TO_A_FILE);
    enable_stdout_logging = environment_get_variable(K4A_ENABLE_LOG_TO_STDOUT);
    logging_level = environment_get_variable(K4A_LOG_LEVEL);

    if (enable_file_logging && enable_file_logging[0] != '\0')
    {
        // enable_file_logging is valid see if its a file path
        const char *log_file = K4A_LOG_FILE_NAME;
        uint32_t extension_sz = sizeof(LOG_FILE_EXTENSION);

        // If enable_file_logging ends in .log then we use it as a path and or file name, else we use the default
        uint32_t path_length = (uint32_t)strlen(enable_file_logging) + 1;
        if (path_length > extension_sz)
        {
            const char *extension = enable_file_logging + (char)(path_length - extension_sz);
            if (strncmp(extension, LOG_FILE_EXTENSION, extension_sz) == 0)
            {
                log_file = enable_file_logging;
            }
        }

        if (log_file)
        {
            try
            {
                // Create a file rotating logger with 50mb size max and 3 rotated files
                global->env_logger =
                    spdlog::rotating_logger_mt(K4A_LOGGER, log_file, K4A_LOG_FILE_50MB_MAX_SIZE, LOG_FILE_MAX_FILES);

                spdlog::set_pattern("%v");
                global->env_logger->info("\n\nNew logging session started\n");
                global->env_logger_is_file_based = true;
            }
            catch (...)
            {
                // Probably trying to use a file that is already opened by another instance.
                global->env_logger = nullptr;
                printf("ERROR: Logger unable to open log file \"%s\".\n", log_file);
            }
        }
    }

    // log to stdout if enabled via ENV var AND if file logging is not enabled.
    if (K4A_SUCCEEDED(result) && (global->env_logger == nullptr))
    {
        bool enable_stdout_logger = false;

        // Default with user_callback enabled is no stdout logging unless specifically enabled
        if (enable_stdout_logging && enable_stdout_logging[0] != '0')
        {
            enable_stdout_logger = true;
        }
        else if (global->user_callback == nullptr)
        {
            // Default with user_callback disabled is use stdout logging unless specifically disabled
            if (global->user_callback == nullptr &&
                (enable_stdout_logging == nullptr || enable_stdout_logging[0] == '\0' ||
                 (enable_stdout_logging && enable_stdout_logging[0] != '0')))
            {
                enable_stdout_logger = true;
            }
        }

        if (enable_stdout_logger)
        {
            // Unable to turn on color logging due to bug with CTest https://gitlab.kitware.com/cmake/cmake/issues/17620
            global->env_logger = spdlog::stdout_logger_mt(K4A_LOGGER);
        }
    }

    if (K4A_SUCCEEDED(result) && (global->env_logger))
    {
        global->env_log_level = K4A_LOG_LEVEL_ERROR;

        //[2018-08-27 10:44:23.218] [level] [threadID] <message>
        // https://github.com/gabime/spdlog/wiki/3.-Custom-formatting
        spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%^%l%$] [t=%t] %v");

        // Set the default logging level SPD will allow. g_env_log_level will furthar refine this.
        spdlog::set_level(spdlog::level::trace);

        // override the default logging level
        if (logging_level && logging_level[0] != '\0')
        {
            if (logging_level[0] == 't' || logging_level[0] == 'T')
            {
                // capture a severity of trace or higher
                global->env_log_level = K4A_LOG_LEVEL_TRACE;
            }
            else if (logging_level[0] == 'i' || logging_level[0] == 'I')
            {
                // capture a severity of info or higher
                global->env_log_level = K4A_LOG_LEVEL_INFO;
            }
            else if (logging_level[0] == 'w' || logging_level[0] == 'W')
            {
                // capture a severity of warning or higher
                global->env_log_level = K4A_LOG_LEVEL_WARNING;
            }
            else if (logging_level[0] == 'e' || logging_level[0] == 'E')
            {
                // capture a severity of error or higher
                global->env_log_level = K4A_LOG_LEVEL_ERROR;
            }
            else if (logging_level[0] == 'c' || logging_level[0] == 'C')
            {
                // capture a severity of error or higher
                global->env_log_level = K4A_LOG_LEVEL_CRITICAL;
            }
        }

        global->env_logger->flush_on(spdlog::level::warn);
    }
}