logger.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <map>
 
#include "spdlog/fmt/fmt.h"
 
namespace itk {
 
namespace logger {
 
  enum log_level_t {
    LOG_LEVEL_TRACE = 0,
    LOG_LEVEL_DEBUG = 1,
    LOG_LEVEL_INFO  = 2,
    LOG_LEVEL_WARN  = 3,
    LOG_LEVEL_ERROR = 4,
    LOG_LEVEL_FATAL = 5,
    LOG_LEVEL_OFF   = 6
  };
 
  static const std::map<int, std::string> log_level_map = {
    { LOG_LEVEL_OFF,   "off" },
    { LOG_LEVEL_FATAL, "fatal" },
    { LOG_LEVEL_ERROR, "error" },
    { LOG_LEVEL_WARN,  "warning" },
    { LOG_LEVEL_INFO,  "info" },
    { LOG_LEVEL_DEBUG, "debug" },
    { LOG_LEVEL_TRACE, "trace" }
  };
 
  inline std::string log_level_string(log_level_t level) {
    auto it = log_level_map.find(level);
    if (it == log_level_map.end()) return "unknown";
    return it->second;
  }
 
  extern void set_log_level(std::string name, log_level_t level);
 
  extern void dump_loggers();
 
namespace intf {
 
  class CoreLogger {
  public:
 
    virtual ~CoreLogger() = default;
 
    virtual void log_msg(log_level_t level, const std::string &msg) = 0;
 
    virtual bool should_log(log_level_t level) const = 0;
 
 
    virtual log_level_t get_level() const = 0;
 
    virtual void set_level(log_level_t level) = 0;
 
    virtual void set_pattern(const std::string& pattern) = 0;
 
  }; // CoreLogger
 
} // intf
 
 
namespace make {
 
  extern std::shared_ptr<intf::CoreLogger> CoreLogger(const std::string& logname);
 
} // make
 
 
  template<int LOG_LEVEL>
  class Logger {
  public:
 
    Logger(const std::string& logname) {
      core = itk::logger::make::CoreLogger(logname);
    }
 
 
    template<typename... Args>
    inline void log(log_level_t level, fmt::format_string<Args...> fmt, Args &&...args) {
      if (level >= LOG_LEVEL && core->should_log(level))
        core->log_msg(level, fmt::format(fmt, std::forward<Args>(args)...));
    }
 
    template<typename... Args>
    inline void trace(fmt::format_string<Args...> fmt, Args &&...args) {
      log(LOG_LEVEL_TRACE, fmt, std::forward<Args>(args)...);
    }
 
    template<typename... Args>
    inline void debug(fmt::format_string<Args...> fmt, Args &&...args) {
      log(LOG_LEVEL_DEBUG, fmt, std::forward<Args>(args)...);
    }
 
    template<typename... Args>
    inline void info(fmt::format_string<Args...> fmt, Args &&...args) {
      log(LOG_LEVEL_INFO, fmt, std::forward<Args>(args)...);
    }
 
    template<typename... Args>
    inline void warn(fmt::format_string<Args...> fmt, Args &&...args) {
      log(LOG_LEVEL_WARN, fmt, std::forward<Args>(args)...);
    }
 
    template<typename... Args>
    inline void error(fmt::format_string<Args...> fmt, Args &&...args) {
      log(LOG_LEVEL_ERROR, fmt, std::forward<Args>(args)...);
    }
 
    template<typename... Args>
    inline void fatal(fmt::format_string<Args...> fmt, Args &&...args) {
      log(LOG_LEVEL_FATAL, fmt, std::forward<Args>(args)...);
    }
 
    inline bool should_log(log_level_t level) const { return core->should_log(level); }
 
 
    inline log_level_t get_level() { return core->get_level(); }
 
    inline void set_level(log_level_t level) { core->set_level(level); }
 
    inline void set_pattern(const std::string& pattern) { core->set_pattern(pattern); }
 
 
  private:
    std::shared_ptr<intf::CoreLogger> core;
 
  }; // Logger
 
} // logger
 
  using Logger = logger::Logger<logger::LOG_LEVEL_TRACE>;
 
  extern itk::Logger syslog;
 
} // itk