Logger.h

Go to the documentation of this file.

#ifndef _MADARA_LOGGER_LOGGER_H_
#define _MADARA_LOGGER_LOGGER_H_
 
#include "madara/MadaraExport.h"
#include "madara/LockType.h"
#include <vector>
#include <atomic>
#include <string>
#include <stdio.h>
#include "madara/utility/IntTypes.h"
 
#define madara_logger_log(loggering, level, ...)             \
  if (madara::logger::Logger::get_thread_level() >= 0)       \
  {                                                          \
    if (level <= madara::logger::Logger::get_thread_level()) \
    {                                                        \
      loggering.log(level, __VA_ARGS__);                     \
    }                                                        \
  }                                                          \
  else if (level <= loggering.get_level())                   \
  {                                                          \
    loggering.log(level, __VA_ARGS__);                       \
  }
 
#define madara_logger_ptr_log(loggering, level, ...)                  \
  if (madara::logger::Logger::get_thread_level() >= 0) \
  {                                                                   \
    if (level <= madara::logger::Logger::get_thread_level())          \
    {                                                                 \
      loggering->log(level, __VA_ARGS__);                             \
    }                                                                 \
  }                                                                   \
  else if (level <= loggering->get_level())            \
  {                                                                   \
    loggering->log(level, __VA_ARGS__);                               \
  }
 
#define madara_logger_checked_ptr_log(loggering, level, ...)                  \
  if (loggering && madara::logger::Logger::get_thread_level() >= 0) \
  {                                                                   \
    if (level <= madara::logger::Logger::get_thread_level())          \
    {                                                                 \
      loggering->log(level, __VA_ARGS__);                             \
    }                                                                 \
  }                                                                   \
  else if (loggering && level <= loggering->get_level())            \
  {                                                                   \
    loggering->log(level, __VA_ARGS__);                               \
  }
 
#define madara_logger_cond_log_ptrs(                                      \
    conditional, logger_ptr, alt_logger_ptr, level, ...)                  \
  if (conditional &&                                        \
      (madara::logger::Logger::get_thread_level() >= 0))                  \
  {                                                                       \
    if (level <= madara::logger::Logger::get_thread_level())              \
    {                                                                     \
      logger_ptr->log(level, __VA_ARGS__);                                \
    }                                                                     \
    else                                                                  \
    {                                                                     \
      alt_logger_ptr->log(level, __VA_ARGS__);                            \
    }                                                                     \
  }                                                                       \
  else if (conditional && level <= logger_ptr->get_level()) \
  {                                                                       \
    logger_ptr->log(level, __VA_ARGS__);                                  \
  }                                                                       \
  else                                                                    \
  {                                                                       \
    alt_logger_ptr->log(level, __VA_ARGS__);                              \
  }
 
#define madara_logger_cond_log(                                         \
    conditional, loggering, alt_logger_ptr, level, ...)                 \
  if (conditional && (madara::logger::Logger::get_thread_level() >= 0)) \
  {                                                                     \
    if (level <= madara::logger::Logger::get_thread_level())            \
    {                                                                   \
      loggering.log(level, __VA_ARGS__);                                \
    }                                                                   \
    else                                                                \
    {                                                                   \
      alt_logger_ptr->log(level, __VA_ARGS__);                          \
    }                                                                   \
  }                                                                     \
  else if (conditional && level <= loggering.get_level())               \
  {                                                                     \
    loggering.log(level, __VA_ARGS__);                                  \
  }                                                                     \
  else                                                                  \
  {                                                                     \
    alt_logger_ptr->log(level, __VA_ARGS__);                            \
  }
 
namespace madara
{
namespace logger
{
enum LogLevels
{
  LOG_EMERGENCY = 0,
  LOG_ALWAYS = 0,
  LOG_ERROR = 1,
  LOG_WARNING = 2,
  LOG_MAJOR = 3,
  LOG_MINOR = 4,
  LOG_TRACE = 5,
  LOG_DETAILED = 6,
  LOG_MADARA_MAX = 6
};
 
const int TLS_THREAD_LEVEL_DEFAULT = -1;
const double TLS_THREAD_HZ_DEFAULT = 0.0;
 
class MADARA_EXPORT Logger
{
public:
  Logger(bool log_to_stderr = true);
 
  ~Logger();
 
  void log(int level, const char* message, ...);
 
  void add_file(const std::string& filename);
 
  void add_term(void);
 
  void add_syslog(void);
 
  void set_level(int level);
 
  std::string get_tag(void);
 
  void set_tag(const std::string& tag);
 
  int get_level(void);
 
  void clear(void);
 
  void set_timestamp_format(const std::string& format = "%x %X: ");
 
  static int get_thread_level(void);
 
#if 0
  static std::string get_thread_name(void);
 
  static double get_thread_hertz(void);
 
  static void set_thread_level(int level);
 
  static void set_thread_name(const std::string name);
 
  static void set_thread_hertz(double hertz);
#endif
 
private:
#if 0
  static thread_local int thread_level_;
  static thread_local std::string thread_name_;
  static thread_local double thread_hertz_;
#endif
 
  std::string search_and_insert_custom_tstamp(
      const std::string& buf, const std::string& ts_str);
 
  std::string strip_custom_tstamp(
      const std::string in_str, const std::string ts_str);
 
 
  typedef std::vector<FILE*> FileVectors;
 
  mutable MADARA_LOCK_TYPE mutex_;
 
  FileVectors files_;
 
  std::atomic<int> level_;
 
  bool term_added_;
 
  bool syslog_added_;
 
  std::string tag_;
 
  std::string timestamp_format_;
 
 
  const char* MADARA_GET_TIME_MGT_ = "%MGT";
 
  const char* MADARA_THREAD_NAME_ = "%MTN";
 
  const char* MADARA_THREAD_HERTZ_ = "%MTZ";
};
 
}  // end logger namespace
}  // end madara namespace
 
#include "Logger.inl"
 
#endif  // _MADARA_LOGGER_LOGGER_H_