Logger.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Logger.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once
// STL include(s)
#include <cassert>
#include <ctime>
#include <exception>
#include <functional>
#include <iomanip>
#include <iostream>
#include <memory>
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <thread>
#include <utility>

// clang-format off
//         <tt>std::unique_ptr<const Acts::Logger></tt>
#define ACTS_LOCAL_LOGGER(log_object)                                          \
  struct __local_acts_logger                                                   \
  {                                                                            \
    __local_acts_logger(std::unique_ptr<const ::Acts::Logger> logger):         \
      m_logger(std::move(logger))                                              \
    {}                                                                         \
                                                                               \
    const ::Acts::Logger& operator()() const                                   \
    {                                                                          \
      return *m_logger;                                                        \
    }                                                                          \
                                                                               \
    std::unique_ptr<const ::Acts::Logger> m_logger;                            \
  };                                                                           \
  __local_acts_logger logger(log_object);

// Debug level agnostic implementation of the ACTS_XYZ logging macros
#define ACTS_LOG(level, x)                                                     \
  if (logger().doPrint(level)) {                                               \
    std::ostringstream os;                                                     \
    os << x;                                                                   \
    logger().log(level, os.str());                                             \
  }

#define ACTS_VERBOSE(x)  ACTS_LOG(Acts::Logging::VERBOSE, x)

#define ACTS_DEBUG(x)  ACTS_LOG(Acts::Logging::DEBUG, x)

#define ACTS_INFO(x)  ACTS_LOG(Acts::Logging::INFO, x)

#define ACTS_WARNING(x)  ACTS_LOG(Acts::Logging::WARNING, x)

#define ACTS_ERROR(x)  ACTS_LOG(Acts::Logging::ERROR, x)

#define ACTS_FATAL(x)  ACTS_LOG(Acts::Logging::FATAL, x)
// clang-format on

namespace Acts {

namespace Logging {
enum Level {
  VERBOSE = 0,  
  DEBUG,        
  INFO,         
  WARNING,      
  ERROR,        
  FATAL,        
  MAX           
};

inline std::string_view levelName(Level level) {
  switch (level) {
    case Level::VERBOSE:
      return "VERBOSE";
    case Level::DEBUG:
      return "DEBUG";
    case Level::INFO:
      return "INFO";
    case Level::WARNING:
      return "WARNING";
    case Level::ERROR:
      return "ERROR";
    case Level::FATAL:
      return "FATAL";
    case Level::MAX:
      return "MAX";
    default:
      throw std::invalid_argument{"Unknown level"};
  }
}

#ifdef DOXYGEN








Level getFailureThreshold();

#else

#ifdef ACTS_ENABLE_LOG_FAILURE_THRESHOLD
#ifdef ACTS_LOG_FAILURE_THRESHOLD
// We have a fixed compile time log failure threshold
constexpr Level getFailureThreshold() {
  return Level::ACTS_LOG_FAILURE_THRESHOLD;
}
#else
Level getFailureThreshold();
#endif
#else
constexpr Level getFailureThreshold() {
  // Default "NO" failure threshold
  return Level::MAX;
}
#endif

#endif

void setFailureThreshold(Level level);

class ThresholdFailure : public std::runtime_error {
  using std::runtime_error::runtime_error;
};

class OutputPrintPolicy {
 public:
  virtual ~OutputPrintPolicy() = default;

  virtual void flush(const Level& lvl, const std::string& input) = 0;

  virtual const std::string& name() const = 0;

  virtual std::unique_ptr<OutputPrintPolicy> clone(
      const std::string& name) const = 0;
};

class OutputFilterPolicy {
 public:
  virtual ~OutputFilterPolicy() = default;

  virtual bool doPrint(const Level& lvl) const = 0;

  virtual Level level() const = 0;

  virtual std::unique_ptr<OutputFilterPolicy> clone(Level level) const = 0;
};

class DefaultFilterPolicy final : public OutputFilterPolicy {
 public:
  explicit DefaultFilterPolicy(Level lvl) : m_level(lvl) {
    if (lvl > getFailureThreshold()) {
      throw ThresholdFailure(
          "Requested debug level is incompatible with "
          "the ACTS_LOG_FAILURE_THRESHOLD=" +
          std::string{levelName(getFailureThreshold())} +
          " configuration. See "
          "https://acts.readthedocs.io/en/latest/core/"
          "logging.html#logging-thresholds");
    }
  }

  ~DefaultFilterPolicy() override = default;

  bool doPrint(const Level& lvl) const override { return m_level <= lvl; }

  Level level() const override { return m_level; }

  std::unique_ptr<OutputFilterPolicy> clone(Level level) const override {
    return std::make_unique<DefaultFilterPolicy>(level);
  }

 private:
  Level m_level;
};

class OutputDecorator : public OutputPrintPolicy {
 public:
  explicit OutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
      : m_wrappee(std::move(wrappee)) {}

  void flush(const Level& lvl, const std::string& input) override {
    m_wrappee->flush(lvl, input);
  }

  const std::string& name() const override { return m_wrappee->name(); }

 protected:
  std::unique_ptr<OutputPrintPolicy> m_wrappee;
};

class NamedOutputDecorator final : public OutputDecorator {
 public:
  NamedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee,
                       const std::string& name, unsigned int maxWidth = 15)
      : OutputDecorator(std::move(wrappee)),
        m_name(name),
        m_maxWidth(maxWidth) {}

  void flush(const Level& lvl, const std::string& input) override {
    std::ostringstream os;
    os << std::left << std::setw(m_maxWidth) << m_name.substr(0, m_maxWidth - 3)
       << input;
    OutputDecorator::flush(lvl, os.str());
  }

  std::unique_ptr<OutputPrintPolicy> clone(
      const std::string& name) const override {
    return std::make_unique<NamedOutputDecorator>(m_wrappee->clone(name), name,
                                                  m_maxWidth);
  }

  const std::string& name() const override { return m_name; }

 private:
  std::string m_name;

  unsigned int m_maxWidth;
};

class TimedOutputDecorator final : public OutputDecorator {
 public:
  TimedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee,
                       const std::string& format = "%X")
      : OutputDecorator(std::move(wrappee)), m_format(format) {}

  void flush(const Level& lvl, const std::string& input) override {
    std::ostringstream os;
    os << std::left << std::setw(12) << now() << input;
    OutputDecorator::flush(lvl, os.str());
  }

  std::unique_ptr<OutputPrintPolicy> clone(
      const std::string& name) const override {
    return std::make_unique<TimedOutputDecorator>(m_wrappee->clone(name),
                                                  m_format);
  }

 private:
  std::string now() const {
    char buffer[20];
    time_t t{};
    std::time(&t);
    std::strftime(buffer, sizeof(buffer), m_format.c_str(), localtime(&t));
    return buffer;
  }

  std::string m_format;
};

class ThreadOutputDecorator final : public OutputDecorator {
 public:
  explicit ThreadOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
      : OutputDecorator(std::move(wrappee)) {}

  void flush(const Level& lvl, const std::string& input) override {
    std::ostringstream os;
    os << std::left << std::setw(20) << std::this_thread::get_id() << input;
    OutputDecorator::flush(lvl, os.str());
  }

  std::unique_ptr<OutputPrintPolicy> clone(
      const std::string& name) const override {
    return std::make_unique<ThreadOutputDecorator>(m_wrappee->clone(name));
  }
};

class LevelOutputDecorator final : public OutputDecorator {
 public:
  explicit LevelOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
      : OutputDecorator(std::move(wrappee)) {}

  void flush(const Level& lvl, const std::string& input) override {
    std::ostringstream os;
    os << std::left << std::setw(10) << toString(lvl) << input;
    OutputDecorator::flush(lvl, os.str());
  }

  std::unique_ptr<OutputPrintPolicy> clone(
      const std::string& name) const override {
    return std::make_unique<LevelOutputDecorator>(m_wrappee->clone(name));
  }

 private:
  std::string toString(const Level& lvl) const {
    static const char* const buffer[] = {"VERBOSE", "DEBUG", "INFO",
                                         "WARNING", "ERROR", "FATAL"};
    return buffer[lvl];
  }
};

class DefaultPrintPolicy final : public OutputPrintPolicy {
 public:
  explicit DefaultPrintPolicy(std::ostream* out = &std::cout) : m_out(out) {}

  void flush(const Level& lvl, const std::string& input) final {
    (*m_out) << input << std::endl;
    if (lvl >= getFailureThreshold()) {
      throw ThresholdFailure(
          "Previous debug message exceeds the "
          "ACTS_LOG_FAILURE_THRESHOLD=" +
          std::string{levelName(getFailureThreshold())} +
          " configuration, bailing out. See "
          "https://acts.readthedocs.io/en/latest/core/"
          "logging.html#logging-thresholds");
    }
  }

  const std::string& name() const override {
    throw std::runtime_error{
        "Default print policy doesn't have a name. Is there no named output in "
        "the decorator chain?"};
  };

  std::unique_ptr<OutputPrintPolicy> clone(
      const std::string& name) const override {
    (void)name;
    return std::make_unique<DefaultPrintPolicy>(m_out);
  };

 private:
  std::ostream* m_out;
};
}  // namespace Logging

class Logger {
 public:
  Logger(std::unique_ptr<Logging::OutputPrintPolicy> pPrint,
         std::unique_ptr<Logging::OutputFilterPolicy> pFilter)
      : m_printPolicy(std::move(pPrint)), m_filterPolicy(std::move(pFilter)) {}

  bool doPrint(const Logging::Level& lvl) const {
    return m_filterPolicy->doPrint(lvl);
  }

  void log(const Logging::Level& lvl, const std::string& input) const {
    if (doPrint(lvl)) {
      m_printPolicy->flush(lvl, input);
    }
  }

  const Logging::OutputPrintPolicy& printPolicy() const {
    return *m_printPolicy;
  }

  const Logging::OutputFilterPolicy& filterPolicy() const {
    return *m_filterPolicy;
  }

  Logging::Level level() const { return m_filterPolicy->level(); }

  const std::string& name() const { return m_printPolicy->name(); }

  std::unique_ptr<Logger> clone(
      const std::optional<std::string>& _name = std::nullopt,
      const std::optional<Logging::Level>& _level = std::nullopt) const {
    return std::make_unique<Logger>(
        m_printPolicy->clone(_name.value_or(name())),
        m_filterPolicy->clone(_level.value_or(level())));
  }

  std::unique_ptr<Logger> clone(Logging::Level _level) const {
    return clone(std::nullopt, _level);
  }

  std::unique_ptr<Logger> cloneWithSuffix(
      const std::string& suffix,
      std::optional<Logging::Level> _level = std::nullopt) const {
    return clone(name() + suffix, _level.value_or(level()));
  }

  const Logger& operator()() const { return *this; }

 private:
  std::unique_ptr<Logging::OutputPrintPolicy> m_printPolicy;

  std::unique_ptr<Logging::OutputFilterPolicy> m_filterPolicy;
};

std::unique_ptr<const Logger> getDefaultLogger(
    const std::string& name, const Logging::Level& lvl,
    std::ostream* log_stream = &std::cout);

const Logger& getDummyLogger();

}  // namespace Acts