logger.hpp

Go to the documentation of this file.

 
#ifndef RAD_LOGGER_HPP
#define RAD_LOGGER_HPP
 
#include <log4cplus/logger.h>
#include <log4cplus/loggingmacros.h>
#include <log4cplus/configurator.h>
#include <log4cplus/initializer.h>
 
#ifdef NDEBUG
#define RAD_TRACE(logger)
#else
#define RAD_TRACE(logger) \
    LOG4CPLUS_TRACE(logger, __FILE__ << " " << __FUNCTION__ << " " << __LINE__)
#endif
 
#if 0
#define LOG4CPLUS_STATE(logger, log_event)                                                      \
    if (logger.isEnabledFor(log4cplus::STATE_LOG_LEVEL)) {                                      \
        log4cplus::tostringstream _log4cplus_buf;                                               \
        _log4cplus_buf << log_event;                                                            \
        logger.forcedLog(log4cplus::STATE_LOG_LEVEL, _log4cplus_buf.str(), __FILE__, __LINE__); \
    }
 
#define LOG4CPLUS_EVENT(logger, log_event)                                                      \
    if (logger.isEnabledFor(log4cplus::EVENT_LOG_LEVEL)) {                                      \
        log4cplus::tostringstream _log4cplus_buf;                                               \
        _log4cplus_buf << log_event;                                                            \
        logger.forcedLog(log4cplus::EVENT_LOG_LEVEL, _log4cplus_buf.str(), __FILE__, __LINE__); \
    }
 
#define LOG4CPLUS_ACTION(logger, log_event)                                                      \
    if (logger.isEnabledFor(log4cplus::ACTION_LOG_LEVEL)) {                                      \
        log4cplus::tostringstream _log4cplus_buf;                                                \
        _log4cplus_buf << log_event;                                                             \
        logger.forcedLog(log4cplus::ACTION_LOG_LEVEL, _log4cplus_buf.str(), __FILE__, __LINE__); \
    }
 
#define LOG4CPLUS_GUARD(logger, log_event)                                                      \
    if (logger.isEnabledFor(log4cplus::GUARD_LOG_LEVEL)) {                                      \
        log4cplus::tostringstream _log4cplus_buf;                                               \
        _log4cplus_buf << log_event;                                                            \
        logger.forcedLog(log4cplus::GUARD_LOG_LEVEL, _log4cplus_buf.str(), __FILE__, __LINE__); \
    }
 
namespace log4cplus {
 
// OFF, FATAL, ERROR, WARN,
// INFO_LOG_LEVEL = 20000
const LogLevel STATE_LOG_LEVEL = 10105;
const LogLevel EVENT_LOG_LEVEL = 10104;
const LogLevel ACTION_LOG_LEVEL = 10102;
const LogLevel GUARD_LOG_LEVEL = 10101;
// DEBUG_LOG_LEVEL = 10000
// TRACE_LOG_LEVEL = 0 (all)
 
static log4cplus::tstring const STATE_LOG_LEVEL_STR(LOG4CPLUS_TEXT("STATE"));
static log4cplus::tstring const EVENT_LOG_LEVEL_STR(LOG4CPLUS_TEXT("EVENT"));
static log4cplus::tstring const ACTION_LOG_LEVEL_STR(LOG4CPLUS_TEXT("ACTION"));
static log4cplus::tstring const GUARD_LOG_LEVEL_STR(LOG4CPLUS_TEXT("GUARD"));
static log4cplus::tstring const EMPTY_LOG_LEVEL_STR(LOG4CPLUS_TEXT(""));
 
}  // namespace log4cplus
#endif
 
namespace rad {
 
const std::string LOGGER_NAME = "rad";
const std::string SM_LOGGER_NAME = "rad.sm";
const std::string APP_LOGGER_NAME = "app";

std::map<std::string, std::string> GetDefaultLogProperties(const std::string&
        logsink_filename, const std::string& log_level = "ERROR");

log4cplus::Logger& GetLogger();

log4cplus::Logger& GetSmLogger();

log4cplus::Logger& GetAppLogger();

log4cplus::Logger& GetRootLogger();
 
 
#if 0
log4cplus::tstring const& RadLogLevelToString(log4cplus::LogLevel ll);
log4cplus::LogLevel RadStringToLogLevel(const log4cplus::tstring& str);
#endif

class LogInitializer {
public:
    inline LogInitializer() {
        log4cplus::BasicConfigurator().configure();
        // log4cplus::Logger::getInstance(rad::LOGGER_NAME).setLogLevel(log4cplus::GUARD_LOG_LEVEL);
        GetLogger().setLogLevel(log4cplus::ERROR_LOG_LEVEL);
        GetSmLogger().setLogLevel(log4cplus::ERROR_LOG_LEVEL);
#if 0
        /*
         * Add RAD specific Log Levels.
         */
        log4cplus::getLogLevelManager().pushToStringMethod(rad::RadLogLevelToString);
        log4cplus::getLogLevelManager().pushFromStringMethod(rad::RadStringToLogLevel);
#endif
    }

    inline ~LogInitializer() = default;

    inline void Configure(const std::string& filename = "") {
        if (filename.size() > 0) {
            log4cplus::PropertyConfigurator::doConfigure(filename);
            LOG4CPLUS_INFO(GetLogger(), "Loaded log properties: " << filename);
        }
    }
 
    LogInitializer(const LogInitializer&) = delete;
    LogInitializer& operator=(const LogInitializer&) = delete;
 
private:
    log4cplus::Initializer m_initializer;
};
 
}  // namespace rad
 
#endif  // RAD_LOGGER_HPP