Log.h

Go to the documentation of this file.

/*
 * Copyright (C) 2019-2025 HERE Europe B.V.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */
 
#pragma once
 
#include <cinttypes>
#include <cstdlib>
#include <sstream>
#include <string>
 
#include <olp/core/logging/Format.h>
#include <olp/core/logging/Level.h>
 
#include <olp/core/CoreApi.h>
#include <olp/core/porting/optional.h>
#include <olp/core/utils/WarningWorkarounds.h>
 
#ifdef LOGGING_DISABLE_LOCATION
 
#define OLP_SDK_LOG_FUNCTION_SIGNATURE ""
#define OLP_SDK_LOG_FILE ""
#define OLP_SDK_LOG_LINE 0
#define OLP_SDK_LOG_FUNCTION ""
 
#else  // LOGGING_DISABLE_LOCATION
 
#if __GNUC__ >= 3 || defined(__clang__)
#define OLP_SDK_LOG_FUNCTION_SIGNATURE __PRETTY_FUNCTION__
#elif defined(_MSC_VER)
#define OLP_SDK_LOG_FUNCTION_SIGNATURE __FUNCSIG__
#else
#define OLP_SDK_LOG_FUNCTION_SIGNATURE __FUNCTION__
#endif
 
#define OLP_SDK_LOG_FILE __FILE__
#define OLP_SDK_LOG_LINE __LINE__
#define OLP_SDK_LOG_FUNCTION __FUNCTION__
 
#endif  // LOGGING_DISABLE_LOCATION
 
#define OLP_SDK_DO_LOG(level, tag, message)                           \
  do {                                                                \
    std::ostringstream __strm;                                        \
    __strm << message;                                                \
    ::olp::logging::Log::logMessage(                                  \
        level, tag, __strm.str(), OLP_SDK_LOG_FILE, OLP_SDK_LOG_LINE, \
        OLP_SDK_LOG_FUNCTION, OLP_SDK_LOG_FUNCTION_SIGNATURE);        \
  }                                                                   \
  OLP_SDK_CORE_LOOP_ONCE()
 
#define OLP_SDK_LOG_CRITICAL(level, tag, message) \
  OLP_SDK_DO_LOG(level, tag, message)
 
#define OLP_SDK_LOG_CRITICAL_INFO(tag, message) \
  OLP_SDK_LOG_CRITICAL(::olp::logging::Level::Info, tag, message)
 
#define OLP_SDK_LOG_CRITICAL_WARNING(tag, message) \
  OLP_SDK_LOG_CRITICAL(::olp::logging::Level::Warning, tag, message)
 
#define OLP_SDK_LOG_CRITICAL_ERROR(tag, message) \
  OLP_SDK_LOG_CRITICAL(::olp::logging::Level::Error, tag, message)
 
#define OLP_SDK_LOG_FATAL(tag, message) \
  OLP_SDK_LOG_CRITICAL(::olp::logging::Level::Fatal, tag, message)
 
#define OLP_SDK_LOG_ABORT(tag, message) \
  do {                                  \
    OLP_SDK_LOG_FATAL(tag, message);    \
    std::abort();                       \
  }                                     \
  OLP_SDK_CORE_LOOP_ONCE()
 
#define OLP_SDK_DO_LOG_F(level, tag, ...)                                    \
  do {                                                                       \
    std::string __message = ::olp::logging::format(__VA_ARGS__);             \
    ::olp::logging::Log::logMessage(level, tag, __message, OLP_SDK_LOG_FILE, \
                                    OLP_SDK_LOG_LINE, OLP_SDK_LOG_FUNCTION,  \
                                    OLP_SDK_LOG_FUNCTION_SIGNATURE);         \
  }                                                                          \
  OLP_SDK_CORE_LOOP_ONCE()
 
#define OLP_SDK_LOG_CRITICAL_F(level, tag, ...) \
  OLP_SDK_DO_LOG_F(level, tag, __VA_ARGS__)
 
#define OLP_SDK_LOG_CRITICAL_INFO_F(tag, ...) \
  OLP_SDK_LOG_CRITICAL_F(::olp::logging::Level::Info, tag, __VA_ARGS__)
 
#define OLP_SDK_LOG_CRITICAL_WARNING_F(tag, ...) \
  OLP_SDK_LOG_CRITICAL_F(::olp::logging::Level::Warning, tag, __VA_ARGS__)
 
#define OLP_SDK_LOG_CRITICAL_ERROR_F(tag, ...) \
  OLP_SDK_LOG_CRITICAL_F(::olp::logging::Level::Error, tag, __VA_ARGS__)
 
#define OLP_SDK_LOG_FATAL_F(tag, ...) \
  OLP_SDK_LOG_CRITICAL_F(::olp::logging::Level::Fatal, tag, __VA_ARGS__)
 
#define OLP_SDK_LOG_ABORT_F(tag, ...)      \
  do {                                     \
    OLP_SDK_LOG_FATAL_F(tag, __VA_ARGS__); \
    std::abort();                          \
  }                                        \
  OLP_SDK_CORE_LOOP_ONCE()
 
#ifdef OLP_SDK_LOGGING_DISABLED
#define OLP_SDK_LOG(level, tag, message) \
  do {                                   \
  }                                      \
  OLP_SDK_CORE_LOOP_ONCE()
#else
 
#define OLP_SDK_LOG(level, tag, message)              \
  do {                                                \
    if (::olp::logging::Log::isEnabled(level, tag)) { \
      OLP_SDK_DO_LOG(level, tag, message);            \
    }                                                 \
  }                                                   \
  OLP_SDK_CORE_LOOP_ONCE()
 
#endif  // OLP_SDK_LOGGING_DISABLED
 
#ifdef LOGGING_DISABLE_DEBUG_LEVEL
#define OLP_SDK_LOG_TRACE(tag, message)   \
  do {                                    \
    ::olp::logging::NullLogStream __strm; \
    __strm << message;                    \
    OLP_SDK_CORE_UNUSED(tag, __strm);     \
  }                                       \
  OLP_SDK_CORE_LOOP_ONCE()
 
#define OLP_SDK_LOG_DEBUG(tag, message)   \
  do {                                    \
    ::olp::logging::NullLogStream __strm; \
    __strm << message;                    \
    OLP_SDK_CORE_UNUSED(tag, __strm);     \
  }                                       \
  OLP_SDK_CORE_LOOP_ONCE()
 
#else
#define OLP_SDK_LOG_TRACE(tag, message) \
  OLP_SDK_LOG(::olp::logging::Level::Trace, tag, message)
 
#define OLP_SDK_LOG_DEBUG(tag, message) \
  OLP_SDK_LOG(::olp::logging::Level::Debug, tag, message)
 
#endif  // LOGGING_DISABLE_DEBUG_LEVEL
 
#define OLP_SDK_LOG_INFO(tag, message) \
  OLP_SDK_LOG(::olp::logging::Level::Info, tag, message)
 
#define OLP_SDK_LOG_WARNING(tag, message) \
  OLP_SDK_LOG(::olp::logging::Level::Warning, tag, message)
 
#define OLP_SDK_LOG_ERROR(tag, message) \
  OLP_SDK_LOG(::olp::logging::Level::Error, tag, message)
 
#ifdef OLP_SDK_LOGGING_DISABLED
#define OLP_SDK_LOG_F(level, tag, ...) \
  do {                                 \
  }                                    \
  OLP_SDK_CORE_LOOP_ONCE()
#else
#define OLP_SDK_LOG_F(level, tag, ...)                \
  do {                                                \
    if (::olp::logging::Log::isEnabled(level, tag)) { \
      OLP_SDK_DO_LOG_F(level, tag, __VA_ARGS__);      \
    }                                                 \
  }                                                   \
  OLP_SDK_CORE_LOOP_ONCE()
 
#endif  // OLP_SDK_LOGGING_DISABLED
 
#ifdef LOGGING_DISABLE_DEBUG_LEVEL
#define OLP_SDK_LOG_TRACE_F(tag, ...) OLP_SDK_CORE_UNUSED(tag, __VA_ARGS__)
#define OLP_SDK_LOG_DEBUG_F(tag, ...) OLP_SDK_CORE_UNUSED(tag, __VA_ARGS__)
#else
#define OLP_SDK_LOG_TRACE_F(tag, ...) \
  OLP_SDK_LOG_F(::olp::logging::Level::Trace, tag, __VA_ARGS__)
 
#define OLP_SDK_LOG_DEBUG_F(tag, ...) \
  OLP_SDK_LOG_F(::olp::logging::Level::Debug, tag, __VA_ARGS__)
 
#endif  // LOGGING_DISABLE_DEBUG_LEVEL
 
#define OLP_SDK_LOG_INFO_F(tag, ...) \
  OLP_SDK_LOG_F(::olp::logging::Level::Info, tag, __VA_ARGS__)
 
#define OLP_SDK_LOG_WARNING_F(tag, ...) \
  OLP_SDK_LOG_F(::olp::logging::Level::Warning, tag, __VA_ARGS__)
 
#define OLP_SDK_LOG_ERROR_F(tag, ...) \
  OLP_SDK_LOG_F(::olp::logging::Level::Error, tag, __VA_ARGS__)
 
namespace olp {
namespace logging {
class Configuration;
class FilterGroup;
 
class NullLogStream {
 public:
  template <typename T>
 
  NullLogStream& operator<<(const T&) {
    return *this;
  }
};
 
class CORE_API Log {
 public:
  static bool configure(Configuration configuration);
 
  static Configuration getConfiguration();
 
  static void setLevel(Level level);
 
  static Level getLevel();
 
  static void setLevel(Level level, const std::string& tag);
 
  static void setLevel(const std::string& level, const std::string& tag);
 
  static porting::optional<Level> getLevel(const std::string& tag);
 
  static void clearLevel(const std::string& tag);
 
  static void clearLevels();
 
  static void applyFilterGroup(const FilterGroup& filters);
 
  static bool isEnabled(Level level);
 
  static bool isEnabled(Level level, const std::string& tag);
 
  static void logMessage(Level level, const std::string& tag,
                         const std::string& message, const char* file,
                         unsigned int line, const char* function,
                         const char* fullFunction);
 
  static void addCensor(const std::string& message);
 
  static void removeCensor(const std::string& message);
};
}  // namespace logging
}  // namespace olp