Logger.h

Go to the documentation of this file.

 
#pragma once
 
#include <spdlog/fmt/bundled/ranges.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <spdlog/sinks/ostream_sink.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/spdlog.h>
 
#include <iostream>
 
#if AUTOPAS_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
#define AutoPasLog_TRACE(...) SPDLOG_LOGGER_CALL(autopas::Logger::get(), spdlog::level::trace, __VA_ARGS__)
#else
#define AutoPasLog_TRACE(...) (void)0
#endif
 
#if AUTOPAS_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
#define AutoPasLog_DEBUG(...) SPDLOG_LOGGER_CALL(autopas::Logger::get(), spdlog::level::debug, __VA_ARGS__)
#else
#define AutoPasLog_DEBUG(...) (void)0
#endif
 
#if AUTOPAS_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
#define AutoPasLog_INFO(...) SPDLOG_LOGGER_CALL(autopas::Logger::get(), spdlog::level::info, __VA_ARGS__)
#else
#define AutoPasLog_INFO(...) (void)0
#endif
 
#if AUTOPAS_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
#define AutoPasLog_WARN(...) SPDLOG_LOGGER_CALL(autopas::Logger::get(), spdlog::level::warn, __VA_ARGS__)
#else
#define AutoPasLog_WARN(...) (void)0
#endif
 
#if AUTOPAS_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
#define AutoPasLog_ERROR(...) SPDLOG_LOGGER_CALL(autopas::Logger::get(), spdlog::level::err, __VA_ARGS__)
#else
#define AutoPasLog_ERROR(...) (void)0
#endif
 
#if AUTOPAS_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
#define AutoPasLog_CRITICAL(...) SPDLOG_LOGGER_CALL(autopas::Logger::get(), spdlog::level::critical, __VA_ARGS__)
#else
#define AutoPasLog_CRITICAL(...) (void)0
#endif
#define AutoPasLog(lvl, fmt, ...) AutoPasLog_##lvl(fmt, ##__VA_ARGS__)
 
namespace autopas {
class Logger {
  static inline const std::string loggerName = "AutoPasLog";
 
 public:
  using LogLevel = spdlog::level::level_enum;
 
  static std::shared_ptr<spdlog::logger> get() {
    auto logger = spdlog::get(loggerName);
    if (logger) {
      return logger;
    }
 
    // Logger not found? Create a default one safely.
    std::lock_guard<std::mutex> lock(_registrationMutex);
 
    // Double-check after locking in case another thread created it just now
    logger = spdlog::get(loggerName);
    if (not logger) {
      logger = create_internal(std::cout);  // Default to cout
    }
    return logger;
  }
 
  static void create(std::ostream &logOutputStream = std::cout) {
    std::lock_guard<std::mutex> lock(_registrationMutex);
    unregister_internal();  // Drop old one first
    create_internal(logOutputStream);
  }
 
  static void create(const std::string &filename) {
    std::lock_guard<std::mutex> lock(_registrationMutex);
    unregister_internal();  // Drop old one first
 
    auto logger = spdlog::basic_logger_mt(loggerName, filename);
    logger->flush_on(spdlog::level::warn);
    // spdlog automatically registers the logger upon creation via factory methods
  }
 
  static void unregister() {
    std::lock_guard<std::mutex> lock(_registrationMutex);
    unregister_internal();
  }
 
 private:
  static inline std::mutex _registrationMutex;
 
  static std::shared_ptr<spdlog::logger> create_internal(std::ostream &oss) {
    std::shared_ptr<spdlog::sinks::sink> ostreamSink;
#ifdef AUTOPAS_COLORED_CONSOLE_LOGGING
    if (oss.rdbuf() == std::cout.rdbuf()) {
      ostreamSink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
    } else if (oss.rdbuf() == std::cerr.rdbuf()) {
      ostreamSink = std::make_shared<spdlog::sinks::stderr_color_sink_mt>();
    } else {  // no color for streams other than cout / cerr
      ostreamSink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
    }
#else
    ostreamSink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
#endif
    auto logger = std::make_shared<spdlog::logger>(loggerName, ostreamSink);
    // The logger is normally only flushed on successful program termination.
    // This line ensures flushing when log messages of level warning or more severe are created.
    logger->flush_on(spdlog::level::warn);
    spdlog::register_logger(logger);
    return logger;
  }
 
  static void unregister_internal() { spdlog::drop(loggerName); }
};  // class Logger
}  // namespace autopas