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>

#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";

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

void LogInitialize();
void LogConfigure(const std::string& filename = "");
log4cplus::Logger& GetLogger();
log4cplus::Logger& GetSmLogger();

}  // 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