Logger.hpp

Go to the documentation of this file.

#ifndef RAD_LOGGER_HPP
#define RAD_LOGGER_HPP

#include <cstring>
#include <sstream>
#include <stdio.h>
#include <string>
#include <sys/time.h>


namespace rad {

inline static double GetTime() {
    struct timeval tp;
    gettimeofday(&tp, NULL);
    return (tp.tv_sec + (tp.tv_usec / 1e6));
}

inline static std::string ConvertToIsoTime(const double timestamp) {
    char tmp_iso_time[80];
    long seconds = timestamp;
    strftime(tmp_iso_time, 80, "%Y-%m-%dT%H:%M:%S", localtime(&seconds));
    char tmp_mus[80];
    snprintf(tmp_mus, sizeof(tmp_mus), "%.6f", (timestamp - seconds));
    char iso_time[87];
    snprintf(iso_time, sizeof(iso_time), "%s.%s", tmp_iso_time,
             std::string(tmp_mus).substr(2).c_str());

    return iso_time;
}

inline static std::string GetTimestamp() {
    return rad::ConvertToIsoTime(rad::GetTime());
#if 0
  char buffer[RAD_LOG_TIMESTAMP_MAXLEN];
  char result[RAD_LOG_TIMESTAMP_MAXLEN];

  time_t rawTime;
  time(&rawTime);

  struct tm *timeInfo;
  timeInfo = localtime(&rawTime);

  strftime(buffer, RAD_LOG_TIMESTAMP_MAXLEN, "%Y-%m-%dT%H:%M:%S", timeInfo);

  struct timeval tv;
  gettimeofday(&tv, nullptr /*obsolete*/);
  snprintf(result, RAD_LOG_TIMESTAMP_MAXLEN, "%s.%6.6ld", buffer, tv.tv_usec);

  return result;
#endif
}



/*
 * 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 mOutput;

private:
  Logger(const Logger &);
  Logger &operator=(const Logger &);
};

Logger::~Logger() {
  mOutput << std::endl;
  if (Logger::EnableConsole() == true) {
    fprintf(stdout, "%s %s %s %s", rad::GetTimestamp().c_str(), ModuleName().c_str(),
            ModuleName().c_str(), mOutput.str().c_str());
    fflush(stdout);
  }

  if (Logger::EnableLogMon() == true) {
    // @TODO add code to verbose the log somewhere
  }
}

std::ostringstream& Logger::Get(LogLevel level) {
  mOutput << LevelToString(level) << " ";
  return mOutput;
}

LogLevel& Logger::ReportingLevel() {
  static LogLevel reportingLevel = LOG_LEVEL_INFO;
  return reportingLevel;
}

bool &Logger::EnableConsole() {
  static bool isConsoleEnabled = false;
  return isConsoleEnabled;
}

bool &Logger::EnableLogMon() {
  static bool isLogMonEnabled = false;
  return isLogMonEnabled;
}

bool Logger::IsEnabled() {
  return Logger::EnableConsole() == true || Logger::EnableLogMon() == true;
}

std::string& Logger::ModuleName() {
  static std::string modName = ""; // @TODO initialized to module name
  return modName;
}

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(isEnabled) rad::Logger::EnableLogMon() = isEnabled
#define RAD_LOG_TO_CONSOLE(isEnabled) rad::Logger::EnableConsole() = isEnabled

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

#define RAD_LOG_STATE(a, b) rad::LogStateFunction(a, b)
#define RAD_LOG_EVENT(a)    rad::LogEventFunction(a)
#define RAD_LOG_GUARD(a)    rad::LogFunction(rad::LOG_LEVEL_GUARD, __FUNCTION__, a)
#define RAD_LOG_ACTION(a)   rad::LogFunction(rad::LOG_LEVEL_ACTION, __FUNCTION__, a)
#define RAD_LOG_TRACE()     rad::LogTraceFunction(rad::LOG_LEVEL_TRACE, __FILE__, __FUNCTION__, __LINE__)


#endif //__LOGGER_H__