logger.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2024 Regents of the University of California.
 *
 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
 *
 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
 *
 * You should have received copies of the GNU General Public License and GNU Lesser
 * General Public License along with ndn-cxx, e.g., in COPYING.md file.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
 */
 
#ifndef NDN_CXX_UTIL_LOGGER_HPP
#define NDN_CXX_UTIL_LOGGER_HPP
 
#include "ndn-cxx/detail/config.hpp"
 
#ifdef HAVE_NDN_CXX_CUSTOM_LOGGER
#include "ndn-cxx/util/custom-logger.hpp"
#else
 
#include <boost/log/common.hpp>
#include <boost/log/expressions/keyword.hpp>
#include <boost/log/sources/severity_logger.hpp>
 
#include <atomic>
#include <iosfwd>
#include <string>
#include <string_view>
 
namespace ndn::util {
 
enum class LogLevel {
  FATAL   = -1,   
  NONE    = 0,    
  ERROR   = 1,    
  WARN    = 2,    
  INFO    = 3,    
  DEBUG   = 4,    
  TRACE   = 5,    
  ALL     = 255   
};
 
std::ostream&
operator<<(std::ostream& os, LogLevel level);
 
LogLevel
parseLogLevel(std::string_view s);
 
namespace log {
 
BOOST_LOG_ATTRIBUTE_KEYWORD(module, "Module", std::string)
BOOST_LOG_ATTRIBUTE_KEYWORD(severity, "Severity", LogLevel)
 
} // namespace log
 
class Logger : public boost::log::sources::severity_logger_mt<LogLevel>
{
public:
  explicit
  Logger(const char* name);
 
  static void
  registerModuleName(const char* name);
 
  const std::string&
  getModuleName() const
  {
    return m_moduleName;
  }
 
  bool
  isLevelEnabled(LogLevel level) const
  {
    return m_currentLevel.load(std::memory_order_relaxed) >= level;
  }
 
  void
  setLevel(LogLevel level)
  {
    m_currentLevel.store(level, std::memory_order_relaxed);
  }
 
private:
  const std::string m_moduleName;
  std::atomic<LogLevel> m_currentLevel;
};
 
namespace detail {
 
template<class T>
struct ExtractArgument;
 
template<class T, class U>
struct ExtractArgument<T(U&)>
{
  using type = U;
};
 
template<class T, class U>
struct ExtractArgument<T(U)&>
{
  using type = U;
};
 
template<class T>
using ArgumentType = typename ExtractArgument<T>::type;
} // namespace detail
 
// implementation detail
#define NDN_LOG_REGISTER_NAME(name) \
  []() -> bool { \
    ::ndn::util::Logger::registerModuleName(BOOST_STRINGIZE(name)); \
    return true; \
  }()
 
// implementation detail
#define NDN_LOG_INIT_FUNCTION_BODY(name) \
  { \
    static ::ndn::util::Logger logger(BOOST_STRINGIZE(name)); \
    return logger; \
  }
#define NDN_LOG_INIT(name) \
  namespace { \
    const bool ndn_cxx_loggerRegistration __attribute__((used)) = NDN_LOG_REGISTER_NAME(name); \
    ::ndn::util::Logger& ndn_cxx_getLogger() \
    NDN_LOG_INIT_FUNCTION_BODY(name) \
  } \
  struct ndn_cxx_allow_trailing_semicolon
 
#define NDN_LOG_MEMBER_DECL() \
  static ::ndn::util::Logger& ndn_cxx_getLogger(); \
  private: \
  static const bool ndn_cxx_loggerRegistration
 
#define NDN_LOG_MEMBER_INIT(cls, name) \
  const bool ::ndn::util::detail::ArgumentType<void(cls&)>::ndn_cxx_loggerRegistration = \
  NDN_LOG_REGISTER_NAME(name); \
  ::ndn::util::Logger& ::ndn::util::detail::ArgumentType<void(cls&)>::ndn_cxx_getLogger() \
  NDN_LOG_INIT_FUNCTION_BODY(name) \
  struct ndn_cxx_allow_trailing_semicolon
 
#define NDN_LOG_MEMBER_DECL_SPECIALIZED(cls) \
  template<> \
  const bool ::ndn::util::detail::ArgumentType<void(cls&)>::ndn_cxx_loggerRegistration; \
  template<> \
  ::ndn::util::Logger& ::ndn::util::detail::ArgumentType<void(cls&)>::ndn_cxx_getLogger()
 
#define NDN_LOG_MEMBER_INIT_SPECIALIZED(cls, name) \
  template<> \
  const bool ::ndn::util::detail::ArgumentType<void(cls&)>::ndn_cxx_loggerRegistration = \
  NDN_LOG_REGISTER_NAME(name); \
  template<> \
  ::ndn::util::Logger& ::ndn::util::detail::ArgumentType<void(cls&)>::ndn_cxx_getLogger() \
  NDN_LOG_INIT_FUNCTION_BODY(name) \
  struct ndn_cxx_allow_trailing_semicolon
 
// implementation detail
#define NDN_LOG_INTERNAL(lvl, expression) \
  do { \
    if (ndn_cxx_getLogger().isLevelEnabled(::ndn::util::LogLevel::lvl)) { \
      BOOST_LOG_SEV(ndn_cxx_getLogger(), ::ndn::util::LogLevel::lvl)  \
        << expression; \
    } \
  } while (false)
#define NDN_LOG_TRACE(expression) NDN_LOG_INTERNAL(TRACE, expression)
 
#define NDN_LOG_DEBUG(expression) NDN_LOG_INTERNAL(DEBUG, expression)
 
#define NDN_LOG_INFO(expression) NDN_LOG_INTERNAL(INFO, expression)
 
#define NDN_LOG_WARN(expression) NDN_LOG_INTERNAL(WARN, expression)
 
#define NDN_LOG_ERROR(expression) NDN_LOG_INTERNAL(ERROR, expression)
 
#define NDN_LOG_FATAL(expression) NDN_LOG_INTERNAL(FATAL, expression)
 
} // namespace ndn::util
 
#endif // HAVE_NDN_CXX_CUSTOM_LOGGER
 
#endif // NDN_CXX_UTIL_LOGGER_HPP