Logger.hh

//
// This file is part of MARLEY (Model of Argon Reaction Low Energy Yields)
//
// MARLEY is free software: you can redistribute it and/or modify it under the
// terms of version 3 of the GNU General Public License as published by the
// Free Software Foundation.
//
// For the full text of the license please see COPYING or
// visit http://opensource.org/licenses/GPL-3.0
//
// Please respect the MCnet academic usage guidelines. See GUIDELINES
// or visit https://www.montecarlonet.org/GUIDELINES for details.
 
#pragma once
#include <algorithm>
#include <fstream>
#include <memory>
#include <mutex>
#include <sstream>
#include <unordered_map>
#include <vector>
 
// Define numerical values for the severity levels in a form that can be
// understood by the preprocessor (enums aren't available yet)
#define MARLEY_LOGGER_LEVEL_TRACE  0
#define MARLEY_LOGGER_LEVEL_DEBUG  1
#define MARLEY_LOGGER_LEVEL_INFO   2
#define MARLEY_LOGGER_LEVEL_NOTICE 3
#define MARLEY_LOGGER_LEVEL_WARN   4
#define MARLEY_LOGGER_LEVEL_ERROR  5
#define MARLEY_LOGGER_LEVEL_FATAL  6
 
// Double-expansion helper that allows a severity level token (e.g., INFO) to
// be assigned to MARLEY_COMPILED_LOG_LEVEL and matched to one of the numerical
// values above. This is used below to enable numerical comparison in
// MARLEY_LOG_IMPL without needing to reference the numerical values above
// when configuring CMake or GNU Make.
#define MARLEY_LOG_LEVEL_NUM(level) MARLEY_LOG_LEVEL_NUM_IMPL(level)
#define MARLEY_LOG_LEVEL_NUM_IMPL(level) MARLEY_LOGGER_LEVEL_##level
 
// Default to maximum severity of INFO (this can be overriden via injection
// of a different definition for this macro at compile time). Anything below
// this is blocked from execution at compile time, preventing
// debugging messages from impairing runtime performance when they are not
// enabled.
#ifndef MARLEY_COMPILED_LOG_LEVEL
  #define MARLEY_COMPILED_LOG_LEVEL INFO
#endif
 
// Main user-facing macro (accepts one or two arguments depending on
// whether a category is specified)
#define MARLEY_LOG(...) \
    MARLEY_LOG_SELECT(__VA_ARGS__, \
        MARLEY_LOG_2, \
        MARLEY_LOG_1) \
    (__VA_ARGS__)
 
#define MARLEY_LOG_SELECT(_1,_2,NAME,...) NAME
 
#define MARLEY_LOG_1(level) MARLEY_LOG_IMPL(level,"")
#define MARLEY_LOG_2(level, category) MARLEY_LOG_IMPL(level,category)
 
#define MARLEY_LOG_IMPL(level, category) \
  ( MARLEY_LOG_LEVEL_NUM(MARLEY_COMPILED_LOG_LEVEL) \
    <= MARLEY_LOGGER_LEVEL_##level ) && \
  marley::Logger::Instance().log( marley::Logger::LogLevel::level, category )
 
// Forward declare some MARLEY classes and their operator<< functions so that
// we can stream them to the Logger
namespace marley {
  class HauserFeshbachDecay;
  class JSON;
  class Parity;
  class Target;
  class TargetAtom;
}
 
std::ostream& operator<<( std::ostream& out,
  const marley::HauserFeshbachDecay& hfd );
 
std::ostream& operator<<( std::ostream& os, const marley::JSON& json );
std::ostream& operator<<( std::ostream& out, const marley::Parity& p );
std::ostream& operator<<( std::ostream& out, const marley::Target& t );
std::ostream& operator<<( std::ostream& out, const marley::TargetAtom& ta );
 
namespace marley {

  class Logger {
 
    public:

      enum class LogLevel {
        TRACE  = MARLEY_LOGGER_LEVEL_TRACE,
        DEBUG  = MARLEY_LOGGER_LEVEL_DEBUG,
        INFO   = MARLEY_LOGGER_LEVEL_INFO,
        NOTICE = MARLEY_LOGGER_LEVEL_NOTICE,
        WARN   = MARLEY_LOGGER_LEVEL_WARN,
        ERROR  = MARLEY_LOGGER_LEVEL_ERROR,
        FATAL  = MARLEY_LOGGER_LEVEL_FATAL,
      };
 
    private:

      const char* loglevel_to_str( LogLevel lev );

      class OutStream {
 
        friend class Logger;
 
        public:

          OutStream( std::shared_ptr< std::ostream > os,
            LogLevel min, LogLevel max );

          OutStream( std::ostream& os, LogLevel min, LogLevel max );
 
        private:

          std::shared_ptr< std::ostream > stream_;

          LogLevel min_level_;

          LogLevel max_level_;
      };
 
    public:

      class Message {
 
        public:
 
          Message( std::vector< std::ostream* >& vec, std::mutex* mtx )
            : osvec_( vec ), mtx_( mtx ) {}
 
          // Copy constructors cannot be defaulted because the class owns
          // a std::ostringstream, which has a deleted copy constructor.
          // However, the stream can be moved, so we take advantage of this
          // here to allow returning a Message by value.
          Message( Message&& other ) = default;
          Message& operator=( Message&& other ) = default;
 
          // Allows conversion to bool to get the types to work in the MARLEY_LOG_IMPL macro.
          // The return value is not intended to be used anywhere.
          inline explicit operator bool() const { return true; }
 
          inline ~Message() {
            // If we have no active OutStreams, then just destroy the Message
            // without any output
            if ( osvec_.empty() ) return;
            // Otherwise, append a new line, apply a lock to protect against
            // activity from other threads, and write to each active OutStream
            buffer_ << '\n';
            std::string msg = buffer_.str();
            std::lock_guard< std::mutex > lock( *mtx_ );
            for ( auto& s : osvec_ ) *s << msg;
          }
 
          template< typename OutputType > Message&
            operator<<( const OutputType& out )
          {
            // If we have no active OutStreams, then don't both to store the
            // streaming output (since it will not be sent anywhere by the
            // destructor
            if ( !osvec_.empty() ) buffer_ << out;
            return *this;
          }

          Message& operator<<( std::ostream& (*manip)(std::ostream&) );

          Message& operator<<( std::ios_base& (*manip)(std::ios_base&) );
 
        protected:

          std::ostringstream buffer_;

          std::vector< std::ostream* > osvec_;

          std::mutex* mtx_;
      };

      Logger();

      void configure( const marley::JSON& json );
 
      static LogLevel string_to_loglevel( const std::string& str );

      static Logger& Instance();

      bool has_stream( const std::ostream& stream ) const;

      Message log( LogLevel lev, const std::string& category = "" );

      inline bool should_emit( const std::string& category, LogLevel lev );

      LogLevel category_level( const std::string& category );
 
      // Make the singleton Logger uncopyable and unmovable
      Logger( const Logger& ) = delete;
      Logger& operator=( const Logger& ) = delete;
      Logger( Logger&& ) = delete;
      Logger& operator=( Logger&& ) = delete;
 
    private:

      void add_stream( std::shared_ptr< std::ostream > stream,
        LogLevel min, LogLevel max );

      void add_stream( std::ostream& stream, LogLevel min, LogLevel max );
 
      // @brief Returns a pointer to the given stream's OutStream object if
      // it has been added to the Logger, or nullptr otherwise.
      const OutStream* get_stream( const std::ostream* os ) const;
 
      // @brief Returns a pointer to the given stream's OutStream object if
      // it has been added to the Logger, or nullptr otherwise.
      OutStream* get_stream( const std::ostream* os );

      std::vector< OutStream > streams_;

      LogLevel default_level_ = LogLevel::INFO;

      std::unordered_map< std::string, LogLevel > category_map_;

      std::unordered_map< std::string, LogLevel > resolved_level_cache_;

      std::mutex mutex_;

      static constexpr char CATEG_DELIM_ = '.';
  };
 
}
 
// Inline function definitions
inline bool marley::Logger::should_emit( const std::string& category,
  LogLevel lev )
{
  LogLevel cl = this->category_level( category );
  return ( lev >= cl );
}