logger.hpp

Go to the documentation of this file.

// Copyright 2019 Lawrence Livermore National Security, LLC and other Metall
// Project Developers. See the top-level COPYRIGHT file for details.
//
// SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
#ifndef METALL_LOGGER_HPP
#define METALL_LOGGER_HPP
 
#include <cstring>
#include <optional>
#include <sstream>
#include <metall/logger_interface.h>
 
namespace metall {
 
class logger {
 public:
  enum struct level {
    critical = metall_critical,
    error = metall_error,
    warning = metall_warning,
    info = metall_info,
    debug = metall_debug,
    verbose = metall_verbose,
  };
 
  static void out(const level lvl, const char* const file_name,
                  const int line_no, const char* const message) noexcept {
    metall_log(static_cast<metall_log_level>(lvl), file_name, line_no, message);
  }
 
  static void perror(const level lvl, const char* const file_name,
                     const int line_no, const char* const message) noexcept {
    std::stringstream ss;
    ss << message << ": " << strerror(errno);
 
    auto const m = ss.str();
    metall_log(static_cast<metall_log_level>(lvl), file_name, line_no, m.c_str());
  }
 
  logger() = delete;
  ~logger() = delete;
  logger(const logger&) = delete;
  logger(logger&&) = delete;
  logger& operator=(const logger&) = delete;
  logger& operator=(logger&&) = delete;
 
#ifndef METALL_LOGGER_EXTERN_C
  struct level_filter {
  private:
    std::optional<level> inner;
 
    explicit level_filter(std::optional<level> inner) noexcept : inner{inner} {
    }
 
  public:
    static const level_filter critical;
    static const level_filter error;
    static const level_filter warning;
    static const level_filter info;
    static const level_filter debug;
    static const level_filter verbose;
    static const level_filter silent;
 
    bool should_log(level lvl) const noexcept {
      return inner.has_value() && lvl >= *inner;
    }
  };
 
  static level_filter log_level() noexcept {
    return log_message_out_level;
  }
 
  static void set_log_level(const level_filter lvl) noexcept {
    log_message_out_level = lvl;
  }
 
  static bool abort_on_critical_error() noexcept {
    return abort_on_critical;
  }
 
  static void abort_on_critical_error(const bool enable) noexcept {
    abort_on_critical = enable;
  }
 
private:
  static level_filter log_message_out_level;
  static bool abort_on_critical;
#endif // METALL_LOGGER_EXTERN_C
};
 
#ifndef METALL_LOGGER_EXTERN_C
inline const logger::level_filter logger::level_filter::critical{logger::level::critical};
inline const logger::level_filter logger::level_filter::error{logger::level::error};
inline const logger::level_filter logger::level_filter::warning{logger::level::warning};
inline const logger::level_filter logger::level_filter::info{logger::level::info};
inline const logger::level_filter logger::level_filter::debug{logger::level::debug};
inline const logger::level_filter logger::level_filter::verbose{logger::level::verbose};
inline const logger::level_filter logger::level_filter::silent{std::nullopt};
 
inline logger::level_filter logger::log_message_out_level = logger::level_filter::error;
inline bool logger::abort_on_critical = true;
#endif // METALL_LOGGER_EXTERN_C
 
}  // namespace metall
 
 
#ifndef METALL_LOGGER_EXTERN_C
#include <iostream>
 
extern "C" inline void metall_log(metall_log_level lvl_, const char *file_name, size_t line_no, const char *message) {
  auto const lvl = static_cast<metall::logger::level>(lvl_);
 
  if (!metall::logger::log_level().should_log(lvl)) {
    return;
  }
 
  try {
    std::cerr << file_name << " at line " << line_no << " --- " << message
              << std::endl;
  } catch (...) {
  }
 
  if (lvl == metall::logger::level::critical && metall::logger::abort_on_critical_error()) {
    std::abort();
  }
}
#endif // METALL_LOGGER_EXTERN_C
 
#endif  // METALL_LOGGER_HPP