simpleLogger.hpp

Go to the documentation of this file.

 
#ifndef RAD_SIMPLE_LOGGER_HPP
#define RAD_SIMPLE_LOGGER_HPP
 
#include <rad/helper.hpp>
#include <source_location>
#include <syslog.h>
 
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;
 
/*
 * SimpleLogger class.
 */
class SimpleLogger {
   public:
    SimpleLogger() : m_level(LOG_LEVEL_ERROR) {};
    inline virtual ~SimpleLogger();
    inline std::ostringstream& Get(const LogLevel level = LOG_LEVEL_INFO,
            const std::source_location& location = std::source_location::current());
 
    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& HostName();
    inline static std::string LevelToString(LogLevel level);
    inline static std::string LevelToStringLogMon(LogLevel level);
    inline static LogLevel LevelFromString(const std::string& level);
    inline static void OpenLogMon(const char* procname);
    inline static void CloseLogMon();
 
   protected:
    std::ostringstream m_output;
    LogLevel m_level;
    std::source_location m_location;
 
   private:
    SimpleLogger(const SimpleLogger&);
    SimpleLogger& operator=(const SimpleLogger&);
};
 
SimpleLogger::~SimpleLogger() {
    if (SimpleLogger::EnableConsole() == true) {
        std::string level_name = LevelToString(m_level);
        if (m_level == LOG_LEVEL_INFO) {
            fprintf(stdout, "%s %s %s %s %s\n",
                    rad::GetTimestamp().c_str(),
                    ModuleName().c_str(),
                    ProcName().c_str(),
                    level_name.c_str(),
                    m_output.str().c_str());
        } else {
            fprintf(stdout, "%s %s %s %s %s:%d %s\n",
                    rad::GetTimestamp().c_str(),
                    ModuleName().c_str(),
                    ProcName().c_str(),
                    level_name.c_str(),
                    m_location.file_name(),
                    m_location.line(),
                    m_output.str().c_str());
        }
        fflush(stdout);
    }
 
    if (SimpleLogger::EnableLogMon() == true) {
        syslog(LOG_INFO,
                "Cref=%s:%d, Date=%s, HostName=%s, LogType=%s, "
                "SourceID=%s, LogID=%s-%d, Message=%s, AppName=%s",
                m_location.file_name(),
                m_location.line(),
                rad::GetTimestamp().c_str(),
                HostName().c_str(),
                LevelToStringLogMon(m_level).c_str(),
                ModuleName().c_str(),
                m_location.function_name(),
                m_location.line(),
                m_output.str().c_str(),
                ProcName().c_str());
    }
}
 
std::ostringstream& SimpleLogger::Get(LogLevel level,
        const std::source_location& location) {
    m_level = level;
    m_location = location;
    return m_output;
}
 
LogLevel& SimpleLogger::ReportingLevel() {
    static LogLevel reporting_level = LOG_LEVEL_INFO;
    return reporting_level;
}
 
bool& SimpleLogger::EnableConsole() {
    static bool is_console_enabled = false;
    return is_console_enabled;
}
 
bool& SimpleLogger::EnableLogMon() {
    static bool is_logmon_enabled = false;
    return is_logmon_enabled;
}
 
bool SimpleLogger::IsEnabled() {
    return SimpleLogger::EnableConsole() == true || SimpleLogger::EnableLogMon() == true;
}
 
std::string& SimpleLogger::ModuleName() {
    static std::string mod_name = "N/A";
    return mod_name;
}
 
std::string& SimpleLogger::ProcName() {
    static std::string proc_name = "N/A";
    return proc_name;
}
 
std::string& SimpleLogger::HostName() {
    static std::string host_name = "N/A";
    return host_name;
}
 
std::string SimpleLogger::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];
}
 
std::string SimpleLogger::LevelToStringLogMon(LogLevel level) {
    static const char* const buffer[] = {"ERROR",  "WARN", "INFO", "INFO",  "INFO",
                                         "INFO", "INFO",    "DEBUG", "DEBUG", "DEBUG",
                                         "DEBUG", "DEBUG",  "TRACE"};
    return (level < LOG_LEVEL_ERROR || level > LOG_LEVEL_TRACE) ? "" : buffer[level];
}
 
LogLevel SimpleLogger::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;
}
 
void SimpleLogger::OpenLogMon(const char* procname) {
    openlog(procname, LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL0);
}
 
void SimpleLogger::CloseLogMon() {
    closelog();
}
 
inline void LogTraceFunction(const LogLevel level, const char* filename, const char* funcname,
                             const int linenum) {
    if (level <= SimpleLogger::ReportingLevel() && SimpleLogger::IsEnabled()) {
        SimpleLogger().Get(level) << filename << ":" << linenum << " " << funcname;
    }
}
 
inline void LogFunction(const LogLevel level, const char* funcname, const std::string& a) {
    if (level <= SimpleLogger::ReportingLevel() && SimpleLogger::IsEnabled()) {
        SimpleLogger().Get(level) << a << " (" << __FUNCTION__ << ")";
    }
}
 
inline void LogStateFunction(const std::string& a, const std::string& b) {
    if (LOG_LEVEL_STATE <= SimpleLogger::ReportingLevel() && SimpleLogger::IsEnabled()) {
        SimpleLogger().Get(LOG_LEVEL_STATE) << "from " << a << " to " << b;
    }
}
 
inline void LogEventFunction(const std::string& a) {
    if (LOG_LEVEL_EVENT <= SimpleLogger::ReportingLevel() && SimpleLogger::IsEnabled()) {
        SimpleLogger().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::SimpleLogger::ReportingLevel() = rad::SimpleLogger::LevelFromString(levelName)
 
#define RAD_LOG_SETMODNAME(name) rad::SimpleLogger::ModuleName() = name
#define RAD_LOG_SETPROCNAME(name) rad::SimpleLogger::ProcName() = name
#define RAD_LOG_SETHOSTNAME(name) rad::SimpleLogger::HostName() = name
#define RAD_LOG_TO_LOGMON(is_enabled) rad::SimpleLogger::EnableLogMon() = is_enabled
#define RAD_LOG_TO_CONSOLE(is_enabled) rad::SimpleLogger::EnableConsole() = is_enabled
#define RAD_LOG_LOGMON_OPEN(ident) rad::SimpleLogger::OpenLogMon(ident)
#define RAD_LOG_LOGMON_CLOSE() rad::SimpleLogger::CloseLogMon()
 
#define RAD_LOG(level)                              \
    if (level > RAD_LOG_MAX_LEVEL)                  \
        ;                                           \
    else if (level > rad::SimpleLogger::ReportingLevel()) \
        ;                                           \
    else if (rad::SimpleLogger::IsEnabled() == false)     \
        ;                                           \
    else                                            \
        rad::SimpleLogger().Get(level)
 
#define RAD_LOG_ERROR()                                                                    \
    if (rad::LOG_LEVEL_ERROR > rad::SimpleLogger::ReportingLevel() || !rad::SimpleLogger::IsEnabled()) \
        ;                                                                                  \
    else                                                                                   \
        rad::SimpleLogger().Get(rad::LOG_LEVEL_ERROR)
 
#define RAD_LOG_WARNING()                                                                    \
    if (rad::LOG_LEVEL_WARNING > rad::SimpleLogger::ReportingLevel() || !rad::SimpleLogger::IsEnabled()) \
        ;                                                                                    \
    else                                                                                     \
        rad::SimpleLogger().Get(rad::LOG_LEVEL_WARNING)
 
#define RAD_LOG_INFO()                                                                    \
    if (rad::LOG_LEVEL_INFO > rad::SimpleLogger::ReportingLevel() || !rad::SimpleLogger::IsEnabled()) \
        ;                                                                                 \
    else                                                                                  \
        rad::SimpleLogger().Get(rad::LOG_LEVEL_INFO)
 
#define RAD_LOG_DEBUG()                                                                    \
    if (rad::LOG_LEVEL_DEBUG > rad::SimpleLogger::ReportingLevel() || !rad::SimpleLogger::IsEnabled()) \
        ;                                                                                  \
    else                                                                                   \
        rad::SimpleLogger().Get(rad::LOG_LEVEL_DEBUG)
 
#define RAD_LOG_DEBUG1()                                                                    \
    if (rad::LOG_LEVEL_DEBUG1 > rad::SimpleLogger::ReportingLevel() || !rad::SimpleLogger::IsEnabled()) \
        ;                                                                                   \
    else                                                                                    \
        rad::SimpleLogger().Get(rad::LOG_LEVEL_DEBUG1)
 
#define RAD_LOG_DEBUG2()                                                                    \
    if (rad::LOG_LEVEL_DEBUG2 > rad::SimpleLogger::ReportingLevel() || !rad::SimpleLogger::IsEnabled()) \
        ;                                                                                   \
    else                                                                                    \
        rad::SimpleLogger().Get(rad::LOG_LEVEL_DEBUG2)
 
#define RAD_LOG_DEBUG3()                                                                    \
    if (rad::LOG_LEVEL_DEBUG3 > rad::SimpleLogger::ReportingLevel() || !rad::SimpleLogger::IsEnabled()) \
        ;                                                                                   \
    else                                                                                    \
        rad::SimpleLogger().Get(rad::LOG_LEVEL_DEBUG3)
 
#define RAD_LOG_DEBUG4()                                                                    \
    if (rad::LOG_LEVEL_DEBUG4 > rad::SimpleLogger::ReportingLevel() || !rad::SimpleLogger::IsEnabled()) \
        ;                                                                                   \
    else                                                                                    \
        rad::SimpleLogger().Get(rad::LOG_LEVEL_DEBUG4)
 
// (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  // RAD_SIMPLE_LOGGER_HPP