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/version.h>
#include <log4cplus/configurator.h>
#if LOG4CPLUS_VERSION >= LOG4CPLUS_MAKE_VERSION(2,0,0)
#include <log4cplus/initializer.h>
#endif
 
#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";
 
log4cplus::Logger& GetLogger();
log4cplus::Logger& GetSmLogger();
 
[[deprecated("Replaced by rad::LogInitializer object")]]
void LogInitialize();
 
[[deprecated("Replaced by rad::LogInitializer::Configure() method")]]
void LogConfigure(const std::string& filename = "");
 
#if 0
log4cplus::tstring const& RadLogLevelToString(log4cplus::LogLevel ll);
log4cplus::LogLevel RadStringToLogLevel(const log4cplus::tstring& str);
#endif
 
class LogInitializer {
public:
    inline LogInitializer() {
#if LOG4CPLUS_VERSION < LOG4CPLUS_MAKE_VERSION(2,0,0)
        log4cplus::initialize();
#endif
        log4cplus::BasicConfigurator().configure();
        // log4cplus::Logger::getInstance(rad::LOGGER_NAME).setLogLevel(log4cplus::GUARD_LOG_LEVEL);
        GetLogger().setLogLevel(log4cplus::INFO_LOG_LEVEL);
        GetSmLogger().setLogLevel(log4cplus::INFO_LOG_LEVEL);
#if 0
        /*
         * Add RAD specific Log Levels.
         */
        log4cplus::getLogLevelManager().pushToStringMethod(rad::RadLogLevelToString);
        log4cplus::getLogLevelManager().pushFromStringMethod(rad::RadStringToLogLevel);
#endif
    }
 
    inline ~LogInitializer() {
#if LOG4CPLUS_VERSION < LOG4CPLUS_MAKE_VERSION(2,0,0)
        log4cplus::Logger::shutdown();
#endif
    }
 
    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:
#if LOG4CPLUS_VERSION >= LOG4CPLUS_MAKE_VERSION(2,0,0)
    log4cplus::Initializer mInitializer;
#endif
};
 
}  // namespace rad
 
// ============ FOLLOWING CODE IS OBSOLETE! TO BE REMOVED ===========
// When removing the obsolte code, also the dependency between
// core->utils library can be removed in the wscript!
//
//#if 0
#include <rad/helper.hpp>
 
namespace rad {
 
/*
 * Supported Log Levels.
 */
enum LogLevel {
    LOG_LEVEL_UNKNOWN = -1,
    LOG_LEVEL_ERROR = 0,
    LOG_LEVEL_WARNING,
    LOG_LEVEL_STATE,
    LOG_LEVEL_EVENT,
    LOG_LEVEL_GUARD,
    LOG_LEVEL_ACTION,
    LOG_LEVEL_INFO,
    LOG_LEVEL_DEBUG,
    LOG_LEVEL_DEBUG1,
    LOG_LEVEL_DEBUG2,
    LOG_LEVEL_DEBUG3,
    LOG_LEVEL_DEBUG4,
    LOG_LEVEL_TRACE
};
 
const int LOG_MAX_LEVEL = LOG_LEVEL_TRACE;
const int LOG_MAX_LEN = 2048;
const int LOG_TIMESTAMP_MAXLEN = 100;
 
/*
 * Logger class.
 */
class Logger {
   public:
    Logger(){};
    inline virtual ~Logger();
    inline std::ostringstream& Get(LogLevel level = LOG_LEVEL_INFO);
 
    inline static LogLevel& ReportingLevel();
    inline static bool& EnableConsole();
    inline static bool& EnableLogMon();
    inline static bool IsEnabled();
    inline static std::string& ModuleName();
    inline static std::string& ProcName();
    inline static std::string LevelToString(LogLevel level);
    inline static LogLevel LevelFromString(const std::string& level);
 
   protected:
    std::ostringstream m_output;
 
   private:
    Logger(const Logger&);
    Logger& operator=(const Logger&);
};
 
Logger::~Logger() {
    m_output << std::endl;
    if (Logger::EnableConsole() == true) {
        fprintf(stdout, "%s %s %s %s", rad::GetTimestamp().c_str(), ModuleName().c_str(),
                ModuleName().c_str(), m_output.str().c_str());
        fflush(stdout);
    }
 
    if (Logger::EnableLogMon() == true) {
        // @TODO add code to verbose the log somewhere
    }
}
 
std::ostringstream& Logger::Get(LogLevel level) {
    m_output << LevelToString(level) << " ";
    return m_output;
}
 
LogLevel& Logger::ReportingLevel() {
    static LogLevel reporting_level = LOG_LEVEL_INFO;
    return reporting_level;
}
 
bool& Logger::EnableConsole() {
    static bool is_console_enabled = false;
    return is_console_enabled;
}
 
bool& Logger::EnableLogMon() {
    static bool is_logmon_enabled = false;
    return is_logmon_enabled;
}
 
bool Logger::IsEnabled() {
    return Logger::EnableConsole() == true || Logger::EnableLogMon() == true;
}
 
std::string& Logger::ModuleName() {
    static std::string mod_name = "";  // @TODO initialized to module name
    return mod_name;
}
 
std::string Logger::LevelToString(LogLevel level) {
    static const char* const buffer[] = {"ERROR",  "WARNING", "STATE", "EVENT",  "GUARD",
                                         "ACTION", "INFO",    "DEBUG", "DEBUG1", "DEBUG2",
                                         "DEBUG3", "DEBUG4",  "TRACE"};
    return (level < LOG_LEVEL_ERROR || level > LOG_LEVEL_TRACE) ? "" : buffer[level];
}
 
LogLevel Logger::LevelFromString(const std::string& level) {
    if (level == LevelToString(rad::LOG_LEVEL_TRACE)) {
        return rad::LOG_LEVEL_TRACE;
    } else if (level == LevelToString(rad::LOG_LEVEL_DEBUG4)) {
        return rad::LOG_LEVEL_DEBUG4;
    } else if (level == LevelToString(rad::LOG_LEVEL_DEBUG3)) {
        return rad::LOG_LEVEL_DEBUG3;
    } else if (level == LevelToString(rad::LOG_LEVEL_DEBUG2)) {
        return rad::LOG_LEVEL_DEBUG2;
    } else if (level == LevelToString(rad::LOG_LEVEL_DEBUG1)) {
        return rad::LOG_LEVEL_DEBUG1;
    } else if (level == LevelToString(rad::LOG_LEVEL_DEBUG)) {
        return rad::LOG_LEVEL_DEBUG;
    } else if (level == LevelToString(rad::LOG_LEVEL_INFO)) {
        return rad::LOG_LEVEL_INFO;
    } else if (level == LevelToString(rad::LOG_LEVEL_ACTION)) {
        return rad::LOG_LEVEL_ACTION;
    } else if (level == LevelToString(rad::LOG_LEVEL_GUARD)) {
        return rad::LOG_LEVEL_GUARD;
    } else if (level == LevelToString(rad::LOG_LEVEL_EVENT)) {
        return rad::LOG_LEVEL_EVENT;
    } else if (level == LevelToString(rad::LOG_LEVEL_STATE)) {
        return rad::LOG_LEVEL_STATE;
    } else if (level == LevelToString(rad::LOG_LEVEL_WARNING)) {
        return rad::LOG_LEVEL_WARNING;
    } else if (level == LevelToString(rad::LOG_LEVEL_ERROR)) {
        return rad::LOG_LEVEL_ERROR;
    }
    return rad::LOG_LEVEL_UNKNOWN;
}
 
inline void LogTraceFunction(const LogLevel level, const char* filename, const char* funcname,
                             const int linenum) {
    if (level <= Logger::ReportingLevel() && Logger::IsEnabled()) {
        Logger().Get(level) << filename << ":" << linenum << " " << funcname;
    }
}
 
inline void LogFunction(const LogLevel level, const char* funcname, const std::string& a) {
    if (level <= Logger::ReportingLevel() && Logger::IsEnabled()) {
        Logger().Get(level) << a << " (" << __FUNCTION__ << ")";
    }
}
 
inline void LogStateFunction(const std::string& a, const std::string& b) {
    if (LOG_LEVEL_STATE <= Logger::ReportingLevel() && Logger::IsEnabled()) {
        Logger().Get(LOG_LEVEL_STATE) << "from " << a << " to " << b;
    }
}
 
inline void LogEventFunction(const std::string& a) {
    if (LOG_LEVEL_EVENT <= Logger::ReportingLevel() && Logger::IsEnabled()) {
        Logger().Get(LOG_LEVEL_EVENT) << a;
    }
}
 
}  // namespace rad
 
/*
 * Logging definitions
 */
#ifndef RAD_LOG_MAX_LEVEL
#define RAD_LOG_MAX_LEVEL rad::LOG_LEVEL_TRACE
#endif
 
#define RAD_LOG_SETLEVEL(levelName) \
    rad::Logger::ReportingLevel() = rad::Logger::LevelFromString(levelName)
 
#define RAD_LOG_SETMODNAME(name) rad::Logger::ModuleName() = name
#define RAD_LOG_SETPROCNAME(name) rad::Logger::ProcName() = name
#define RAD_LOG_TO_LOGMON(is_enabled) rad::Logger::EnableLogMon() = is_enabled
#define RAD_LOG_TO_CONSOLE(is_enabled) rad::Logger::EnableConsole() = is_enabled
 
#define RAD_LOG(level)                              \
    if (level > RAD_LOG_MAX_LEVEL)                  \
        ;                                           \
    else if (level > rad::Logger::ReportingLevel()) \
        ;                                           \
    else if (rad::Logger::IsEnabled() == false)     \
        ;                                           \
    else                                            \
        rad::Logger().Get(level) << __FILE__ << ":" << __LINE__ << " "
 
#define RAD_LOG_ERROR()                                                                    \
    if (rad::LOG_LEVEL_ERROR > rad::Logger::ReportingLevel() || !rad::Logger::IsEnabled()) \
        ;                                                                                  \
    else                                                                                   \
        rad::Logger().Get(rad::LOG_LEVEL_ERROR) << __FILE__ << ":" << __LINE__ << " "
 
#define RAD_LOG_WARNING()                                                                    \
    if (rad::LOG_LEVEL_WARNING > rad::Logger::ReportingLevel() || !rad::Logger::IsEnabled()) \
        ;                                                                                    \
    else                                                                                     \
        rad::Logger().Get(rad::LOG_LEVEL_WARNING) << __FILE__ << ":" << __LINE__ << " "
 
#define RAD_LOG_INFO()                                                                    \
    if (rad::LOG_LEVEL_INFO > rad::Logger::ReportingLevel() || !rad::Logger::IsEnabled()) \
        ;                                                                                 \
    else                                                                                  \
        rad::Logger().Get(rad::LOG_LEVEL_INFO)
 
#define RAD_LOG_DEBUG()                                                                    \
    if (rad::LOG_LEVEL_DEBUG > rad::Logger::ReportingLevel() || !rad::Logger::IsEnabled()) \
        ;                                                                                  \
    else                                                                                   \
        rad::Logger().Get(rad::LOG_LEVEL_DEBUG) << __FILE__ << ":" << __LINE__ << " "
 
#define RAD_LOG_DEBUG1()                                                                    \
    if (rad::LOG_LEVEL_DEBUG1 > rad::Logger::ReportingLevel() || !rad::Logger::IsEnabled()) \
        ;                                                                                   \
    else                                                                                    \
        rad::Logger().Get(rad::LOG_LEVEL_DEBUG1) << __FILE__ << ":" << __LINE__ << " "
 
#define RAD_LOG_DEBUG2()                                                                    \
    if (rad::LOG_LEVEL_DEBUG2 > rad::Logger::ReportingLevel() || !rad::Logger::IsEnabled()) \
        ;                                                                                   \
    else                                                                                    \
        rad::Logger().Get(rad::LOG_LEVEL_DEBUG2) << __FILE__ << ":" << __LINE__ << " "
 
#define RAD_LOG_DEBUG3()                                                                    \
    if (rad::LOG_LEVEL_DEBUG3 > rad::Logger::ReportingLevel() || !rad::Logger::IsEnabled()) \
        ;                                                                                   \
    else                                                                                    \
        rad::Logger().Get(rad::LOG_LEVEL_DEBUG3) << __FILE__ << ":" << __LINE__ << " "
 
#define RAD_LOG_DEBUG4()                                                                    \
    if (rad::LOG_LEVEL_DEBUG4 > rad::Logger::ReportingLevel() || !rad::Logger::IsEnabled()) \
        ;                                                                                   \
    else                                                                                    \
        rad::Logger().Get(rad::LOG_LEVEL_DEBUG4) << __FILE__ << ":" << __LINE__ << " "
 
// (void)("LCOV_EXCL_BR_LINE") has been added to skip branch coverage the macros.
#define RAD_LOG_STATE(a, b)      \
    rad::LogStateFunction(a, b); \
    (void)("LCOV_EXCL_BR_LINE")
#define RAD_LOG_EVENT(a)      \
    rad::LogEventFunction(a); \
    (void)("LCOV_EXCL_BR_LINE")
#define RAD_LOG_GUARD(a)                                     \
    rad::LogFunction(rad::LOG_LEVEL_GUARD, __FUNCTION__, a); \
    (void)("LCOV_EXCL_BR_LINE")
#define RAD_LOG_ACTION(a)                                     \
    rad::LogFunction(rad::LOG_LEVEL_ACTION, __FUNCTION__, a); \
    (void)("LCOV_EXCL_BR_LINE")
#define RAD_LOG_TRACE()                                                            \
    rad::LogTraceFunction(rad::LOG_LEVEL_TRACE, __FILE__, __FUNCTION__, __LINE__); \
    (void)("LCOV_EXCL_BR_LINE")
//#endif
 
#endif  // RAD_LOGGER_HPP