/home/mhx/git/github/libmoost/include/moost/logging/logger.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_LOGGER_HPP
#define MOOST_LOGGER_HPP

#include <string>
#include <stdexcept>
#include <log4cxx/logger.h>

#include <boost/preprocessor/stringize.hpp>

#include "global.hpp"

#ifdef MLOG_PREFIX
#define MLOG_PREFIX__(msg) \
   BOOST_PP_STRINGIZE(MLOG_PREFIX) << " " << msg
#else
#define MLOG_PREFIX__(msg) msg
#endif

#define MLOG_LEVEL_TRACE LOG4CXX_TRACE
#define MLOG_LEVEL_DEBUG LOG4CXX_DEBUG
#define MLOG_LEVEL_INFO  LOG4CXX_INFO
#define MLOG_LEVEL_WARN  LOG4CXX_WARN
#define MLOG_LEVEL_ERROR LOG4CXX_ERROR
#define MLOG_LEVEL_FATAL LOG4CXX_FATAL

#define MLOG(level, logger, msg) \
   level(logger, MLOG_PREFIX__(msg));

#define MLOG_TRACE(logger, msg) MLOG(MLOG_LEVEL_TRACE, logger, msg)
#define MLOG_DEBUG(logger, msg) MLOG(MLOG_LEVEL_DEBUG, logger, msg)
#define MLOG_INFO(logger, msg)  MLOG(MLOG_LEVEL_INFO, logger, msg)
#define MLOG_WARN(logger, msg)  MLOG(MLOG_LEVEL_WARN, logger, msg)
#define MLOG_ERROR(logger, msg) MLOG(MLOG_LEVEL_ERROR, logger, msg)
#define MLOG_FATAL(logger, msg) MLOG(MLOG_LEVEL_FATAL, logger, msg)

#define MLOG_NAMED_LOGGER(name) \
   log4cxx::Logger::getLogger(name)


#define MLOG_DEFAULT_LOGGER() \
   log4cxx::Logger::getRootLogger()

#define MLOG_NAMED_DEFINE(logger, name) \
   log4cxx::LoggerPtr logger = MLOG_NAMED_LOGGER(name)

#define MLOG_NAMED(level, name, msg) \
   MLOG(level, MLOG_NAMED_LOGGER(name), msg)

#define MLOG_NAMED_TRACE(name, msg) MLOG_NAMED(MLOG_LEVEL_TRACE, name, msg)
#define MLOG_NAMED_DEBUG(name, msg) MLOG_NAMED(MLOG_LEVEL_DEBUG, name, msg)
#define MLOG_NAMED_INFO(name, msg)  MLOG_NAMED(MLOG_LEVEL_INFO, name, msg)
#define MLOG_NAMED_WARN(name, msg)  MLOG_NAMED(MLOG_LEVEL_WARN, name, msg)
#define MLOG_NAMED_ERROR(name, msg) MLOG_NAMED(MLOG_LEVEL_ERROR, name, msg)
#define MLOG_NAMED_FATAL(name, msg) MLOG_NAMED(MLOG_LEVEL_FATAL, name, msg)

#define MLOG_DEFAULT_DEFINE(logger) \
   logger = MLOG_DEFAULT_LOGGER()

#define MLOG_DEFAULT(level, msg) \
   MLOG(level, MLOG_DEFAULT_LOGGER(), msg)

#define MLOG_DEFAULT_TRACE(msg) MLOG_DEFAULT(MLOG_LEVEL_TRACE, msg)
#define MLOG_DEFAULT_DEBUG(msg) MLOG_DEFAULT(MLOG_LEVEL_DEBUG, msg)
#define MLOG_DEFAULT_INFO(msg)  MLOG_DEFAULT(MLOG_LEVEL_INFO, msg)
#define MLOG_DEFAULT_WARN(msg)  MLOG_DEFAULT(MLOG_LEVEL_WARN, msg)
#define MLOG_DEFAULT_ERROR(msg) MLOG_DEFAULT(MLOG_LEVEL_ERROR, msg)
#define MLOG_DEFAULT_FATAL(msg) MLOG_DEFAULT(MLOG_LEVEL_FATAL, msg)

#define MLOG_ASSERT(cond, logger, msg) \
   if(!(cond)) \
   { \
      LOG4CXX_ASSERT(logger, false, MLOG_PREFIX__(msg)); \
      assert(false && "MLOG_ASSERT assertion failure"); \
   }

#define MLOG_NAMED_ASSERT(cond, name, msg) \
   MLOG_ASSERT(cond, MLOG_NAMED_LOGGER(name), msg)

#define MLOG_DEFAULT_ASSERT(cond, msg) \
   MLOG_ASSERT(cond, MLOG_DEFAULT_LOGGER(), msg)

#define MLOG_TEST(level, cond, logger, msg) \
   if(!(cond)) MLOG(level, logger, msg);

#define MLOG_NAMED_TEST(level, cond, name, msg) \
   MLOG(level, cond, MLOG_NAMED_LOGGER(name), msg)

#define MLOG_DEFAULT_TEST(level, cond, msg) \
   MLOG(level, cond, MLOG_DEFAULT_LOGGER(), msg)

#define MLOG_TEST_TRACE(cond, logger, msg) MLOG_TEST(MLOG_LEVEL_TRACE, cond, logger, msg)
#define MLOG_TEST_DEBUG(cond, logger, msg) MLOG_TEST(MLOG_LEVEL_DEBUG, cond, logger, msg)
#define MLOG_TEST_INFO(cond, logger, msg)  MLOG_TEST(MLOG_LEVEL_INFO, cond, logger, msg)
#define MLOG_TEST_WARN(cond, logger, msg)  MLOG_TEST(MLOG_LEVEL_WARN, cond, logger, msg)
#define MLOG_TEST_ERROR(cond, logger, msg) MLOG_TEST(MLOG_LEVEL_ERROR, cond, logger, msg)
#define MLOG_TEST_FATAL(cond, logger, msg) MLOG_TEST(MLOG_LEVEL_FATAL, cond, logger, msg)

#define MLOG_NAMED_TEST_TRACE(cond, name, msg) MLOG_DEFAULT_TEST(MLOG_LEVEL_TRACE, cond, name, msg)
#define MLOG_NAMED_TEST_DEBUG(cond, name, msg) MLOG_DEFAULT_TEST(MLOG_LEVEL_DEBUG, cond, name, msg)
#define MLOG_NAMED_TEST_INFO(cond, name, msg)  MLOG_DEFAULT_TEST(MLOG_LEVEL_INFO, cond, name, msg)
#define MLOG_NAMED_TEST_WARN(cond, name, msg)  MLOG_DEFAULT_TEST(MLOG_LEVEL_WARN, cond, name, msg)
#define MLOG_NAMED_TEST_ERROR(cond, name, msg) MLOG_DEFAULT_TEST(MLOG_LEVEL_ERROR, cond, name, msg)
#define MLOG_NAMED_TEST_FATAL(cond, name, msg) MLOG_DEFAULT_TEST(MLOG_LEVEL_FATAL, cond, name, msg)

#define MLOG_DEFAULT_TEST_TRACE(cond, msg) MLOG_DEFAULT_TEST(MLOG_LEVEL_TRACE, cond, msg)
#define MLOG_DEFAULT_TEST_DEBUG(cond, msg) MLOG_DEFAULT_TEST(MLOG_LEVEL_DEBUG, cond, msg)
#define MLOG_DEFAULT_TEST_INFO(cond, msg)  MLOG_DEFAULT_TEST(MLOG_LEVEL_INFO, cond, msg)
#define MLOG_DEFAULT_TEST_WARN(cond, msg)  MLOG_DEFAULT_TEST(MLOG_LEVEL_WARN, cond, msg)
#define MLOG_DEFAULT_TEST_ERROR(cond, msg) MLOG_DEFAULT_TEST(MLOG_LEVEL_ERROR, cond, msg)
#define MLOG_DEFAULT_TEST_FATAL(cond, msg) MLOG_DEFAULT_TEST(MLOG_LEVEL_FATAL, cond, msg)

#define MLOG_CHECK(cond, logger, msg) \
   MLOG_TEST_ERROR(cond, logger, msg)

#define MLOG_NAMED_CHECK(cond, name, msg) \
   MLOG_CHECK(cond, MLOG_NAMED_LOGGER(name), msg)

#define MLOG_DEFAULT_CHECK(cond, msg) \
   MLOG_CHECK(cond, MLOG_DEFAULT_LOGGER(), msg)

#define MLOG_THROW(cond, logger, msg)\
   if(!(cond)) \
   { \
      MLOG_CHECK(false, logger, msg); \
      std::stringstream oss; \
      oss << msg; \
      throw std::runtime_error(oss.str()); \
   }

#define MLOG_THROW_IF(cond, logger, msg) \
   do { \
      std::ostringstream oss; \
      oss << msg; \
      const std::string& err = oss.str(); \
      if (cond) \
         throw std::runtime_error(err); \
      else \
         MLOG_ERROR(logger, err); \
   } while (0)

#define MLOG_NAMED_THROW(cond, name, msg) \
   MLOG_THROW(cond, MLOG_NAMED_LOGGER(name), msg)

#define MLOG_NAMED_THROW_IF(cond, name, msg) \
   MLOG_THROW_IF(cond, MLOG_NAMED_LOGGER(name), msg)

#define MLOG_DEFAULT_THROW(cond, msg) \
   MLOG_THROW(cond, MLOG_DEFAULT_LOGGER(), msg)

#define MLOG_DEFAULT_THROW_IF(cond, msg) \
   MLOG_THROW_IF(cond, MLOG_DEFAULT_LOGGER(), msg)

#define MLOG_VERIFY(cond, logger, msg) \
   if(!(cond)) \
   { \
      MLOG_ASSERT(false, logger, msg); \
      throw std::runtime_error(msg); \
   }

#define MLOG_NAMED_VERIFY(cond, name, msg) \
   MLOG_VERIFY(cond, MLOG_NAMED_LOGGER(name), msg)

#define MLOG_DEFAULT_VERIFY(cond, msg) \
   MLOG_VERIFY(cond, MLOG_DEFAULT_LOGGER(), msg)

#define MLOG_GET_LEVEL_ALL log4cxx::Level::getAll()
#define MLOG_GET_LEVEL_OFF log4cxx::Level::getOff()
#define MLOG_GET_LEVEL_TRACE log4cxx::Level::getTrace()
#define MLOG_GET_LEVEL_DEBUG log4cxx::Level::getDebug()
#define MLOG_GET_LEVEL_INFO log4cxx::Level::getInfo()
#define MLOG_GET_LEVEL_WARN log4cxx::Level::getWarn()
#define MLOG_GET_LEVEL_ERROR log4cxx::Level::getError()
#define MLOG_GET_LEVEL_FATAL log4cxx::Level::getFatal()

#define MLOG_SET_LEVEL(level, logger) \
   logger->setLevel(level);

#define MLOG_SET_NAMED_LEVEL(level, name) \
   MLOG_SET_LEVEL(level, MLOG_NAMED_LOGGER(name))

#define MLOG_SET_DEFAULT_LEVEL(level) \
   MLOG_SET_LEVEL(level, MLOG_DEFAULT_LOGGER())

#define MLOG_SET_LEVEL_ALL(logger) MLOG_SET_LEVEL(MLOG_GET_LEVEL_ALL, logger)
#define MLOG_SET_LEVEL_OFF(logger) MLOG_SET_LEVEL(MLOG_GET_LEVEL_OFF, logger)
#define MLOG_SET_LEVEL_TRACE(logger) MLOG_SET_LEVEL(MLOG_GET_LEVEL_TRACE, logger)
#define MLOG_SET_LEVEL_DEBUG(logger) MLOG_SET_LEVEL(MLOG_GET_LEVEL_DEBUG, logger)
#define MLOG_SET_LEVEL_INFO(logger) MLOG_SET_LEVEL(MLOG_GET_LEVEL_INFO, logger)
#define MLOG_SET_LEVEL_WARN(logger) MLOG_SET_LEVEL(MLOG_GET_LEVEL_WARN, logger)
#define MLOG_SET_LEVEL_ERROR(logger) MLOG_SET_LEVEL(MLOG_GET_LEVEL_ERROR, logger)
#define MLOG_SET_LEVEL_FATAL(logger) MLOG_SET_LEVEL(MLOG_GET_LEVEL_FATAL, logger)

#define MLOG_SET_NAMED_LEVEL_ALL(name) MLOG_SET_LEVEL(MLOG_GET_LEVEL_ALL, MLOG_NAMED_LOGGER(name))
#define MLOG_SET_NAMED_LEVEL_OFF(name) MLOG_SET_LEVEL(MLOG_GET_LEVEL_OFF, MLOG_NAMED_LOGGER(name))
#define MLOG_SET_NAMED_LEVEL_TRACE(name) MLOG_SET_LEVEL(MLOG_GET_LEVEL_TRACE, MLOG_NAMED_LOGGER(name))
#define MLOG_SET_NAMED_LEVEL_DEBUG(name) MLOG_SET_LEVEL(MLOG_GET_LEVEL_DEBUG, MLOG_NAMED_LOGGER(name))
#define MLOG_SET_NAMED_LEVEL_INFO(name) MLOG_SET_LEVEL(MLOG_GET_LEVEL_INFO, MLOG_NAMED_LOGGER(name))
#define MLOG_SET_NAMED_LEVEL_WARN(name) MLOG_SET_LEVEL(MLOG_GET_LEVEL_WARN, MLOG_NAMED_LOGGER(name))
#define MLOG_SET_NAMED_LEVEL_ERROR(name) MLOG_SET_LEVEL(MLOG_GET_LEVEL_ERROR, MLOG_NAMED_LOGGER(name))
#define MLOG_SET_NAMED_LEVEL_FATAL(name) MLOG_SET_LEVEL(MLOG_GET_LEVEL_FATAL, MLOG_NAMED_LOGGER(name))

#define MLOG_SET_DEFAULT_LEVEL_ALL() MLOG_SET_LEVEL(MLOG_GET_LEVEL_ALL, MLOG_DEFAULT_LOGGER())
#define MLOG_SET_DEFAULT_LEVEL_OFF() MLOG_SET_LEVEL(MLOG_GET_LEVEL_OFF, MLOG_DEFAULT_LOGGER())
#define MLOG_SET_DEFAULT_LEVEL_TRACE() MLOG_SET_LEVEL(MLOG_GET_LEVEL_TRACE, MLOG_DEFAULT_LOGGER())
#define MLOG_SET_DEFAULT_LEVEL_DEBUG() MLOG_SET_LEVEL(MLOG_GET_LEVEL_DEBUG, MLOG_DEFAULT_LOGGER())
#define MLOG_SET_DEFAULT_LEVEL_INFO() MLOG_SET_LEVEL(MLOG_GET_LEVEL_INFO, MLOG_DEFAULT_LOGGER())
#define MLOG_SET_DEFAULT_LEVEL_WARN() MLOG_SET_LEVEL(MLOG_GET_LEVEL_WARN, MLOG_DEFAULT_LOGGER())
#define MLOG_SET_DEFAULT_LEVEL_ERROR() MLOG_SET_LEVEL(MLOG_GET_LEVEL_ERROR, MLOG_DEFAULT_LOGGER())
#define MLOG_SET_DEFAULT_LEVEL_FATAL() MLOG_SET_LEVEL(MLOG_GET_LEVEL_FATAL, MLOG_DEFAULT_LOGGER())

#define MLOG_GET_LEVELSTR_ALL "all"
#define MLOG_GET_LEVELSTR_OFF "off"
#define MLOG_GET_LEVELSTR_TRACE "trace"
#define MLOG_GET_LEVELSTR_DEBUG "debug"
#define MLOG_GET_LEVELSTR_INFO "info"
#define MLOG_GET_LEVELSTR_WARN "warn"
#define MLOG_GET_LEVELSTR_ERROR "error"
#define MLOG_GET_LEVELSTR_FATAL "fatal"

namespace moost { namespace logging {

   inline
   log4cxx::LevelPtr str2level(std::string const level)
   {
      log4cxx::LevelPtr invalid(new log4cxx::Level(-1, LOG4CXX_STR("INVALID"), 7 ));
      log4cxx::LevelPtr new_level = log4cxx::Level::toLevel(level, invalid);

      if (new_level == invalid)
      {
         // [29/3/2011 ricky] we really don't want this to be ignored so after much soul
         // searching I decided this was the best way to handle an invalid level request
         throw std::runtime_error("invalid level string");
      }

      return new_level;
   }

}}

#define MLOG_SET_LEVELSTR(levelstr, logger) \
   MLOG_SET_LEVEL(moost::logging::str2level(levelstr), logger);

#define MLOG_SET_NAMED_LEVELSTR(levelstr, name) \
   MLOG_SET_LEVELSTR(levelstr, MLOG_NAMED_LOGGER(name))

#define MLOG_SET_DEFAULT_LEVELSTR(levelstr) \
   MLOG_SET_LEVELSTR(levelstr, MLOG_DEFAULT_LOGGER())

#endif