logging.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_CORE_LOGGING_H_
#define GENESIS_UTILS_CORE_LOGGING_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2020 Lucas Czech and HITS gGmbH
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lucas.czech@h-its.org>
    Exelixis Lab, Heidelberg Institute for Theoretical Studies
    Schloss-Wolfsbrunnenweg 35, D-69118 Heidelberg, Germany
*/
 
#include "genesis/utils/core/std.hpp"
 
#include <cmath>
#include <iosfwd>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
namespace genesis {
namespace utils {
 
// =============================================================================
//     Macro definitions
// =============================================================================
 
// TODO add TIME1..4 (or TMR maybe) for indented timing logs
// TODO change macros for timing to be out of usual log levels
// TODO define a function that logs the detail column headers (difficult because
// of length difference for file name log detail)
// TODO offer csv as output format
// TODO offer remote streams
 
#ifndef LOG_LEVEL_MAX
 
#    define LOG_LEVEL_MAX genesis::utils::Logging::kDebug4
#endif
 
// TODO make DEBUG a special macro with proper usage makefile etc,
// also add maybe stuff like RELEASE TEST etc, prepend ENV_ or so!
// TODO do an undefine first
 
// override this setting when debugging is turned on (eg by makefile)
#ifdef DEBUG
#    define LOG_LEVEL_MAX genesis::utils::Logging::kDebug4
#endif
 
// define the actual log macro, so that the compiler can prune calls
// to a log with levels above the static max log level
#define GENESIS_LOG(level) \
    if (level > LOG_LEVEL_MAX) ; \
    else if (level > genesis::utils::Logging::max_level()) ; \
    else genesis::utils::Logging().get(__FILE__, __LINE__, GENESIS_FUNC, level)
 
// define a similar log macro, this time changing the details of the message
#define GENESIS_LOG_DETAILS(level, ...) \
    if (level > LOG_LEVEL_MAX) ; \
    else if (level > genesis::utils::Logging::max_level()) ; \
    else genesis::utils::Logging().get(__FILE__, __LINE__, GENESIS_FUNC, level, {__VA_ARGS__})
 
// define standard logging types as macro shortcuts:
 
#define LOG_ERR  GENESIS_LOG(genesis::utils::Logging::kError)
 
#define LOG_WARN GENESIS_LOG(genesis::utils::Logging::kWarning)
 
#define LOG_INFO GENESIS_LOG(genesis::utils::Logging::kInfo)
 
#define LOG_MSG GENESIS_LOG(genesis::utils::Logging::kMessage)
 
#define LOG_MSG1 GENESIS_LOG(genesis::utils::Logging::kMessage1)
 
#define LOG_MSG2 GENESIS_LOG(genesis::utils::Logging::kMessage2)
 
#define LOG_MSG3 GENESIS_LOG(genesis::utils::Logging::kMessage3)
 
#define LOG_MSG4 GENESIS_LOG(genesis::utils::Logging::kMessage4)
 
#define LOG_DBG  GENESIS_LOG(genesis::utils::Logging::kDebug)
 
#define LOG_DBG1 GENESIS_LOG(genesis::utils::Logging::kDebug1)
 
#define LOG_DBG2 GENESIS_LOG(genesis::utils::Logging::kDebug2)
 
#define LOG_DBG3 GENESIS_LOG(genesis::utils::Logging::kDebug3)
 
#define LOG_DBG4 GENESIS_LOG(genesis::utils::Logging::kDebug4)
 
// define special log shortcuts: the list of bools represent
// the members of struct LogDetails and indicate which parts shall be included.
 
#define LOG_BOLD GENESIS_LOG_DETAILS(genesis::utils::Logging::kNone, \
    false, false, false, false, false, false, false, false, false)
 
#define LOG_TIME GENESIS_LOG_DETAILS(genesis::utils::Logging::kDebug, \
    false, false, false, false , true,  false, false, false, false)
 
#define LOG_SCOPE_LEVEL(level) \
    genesis::utils::LoggingScopeLevel genesis_logging_scope_level_temp_object(level);
 
inline long logging_progress_value (long value = -1)
{
    static long v = -1;
    if (value > -1) {
        v = value;
    }
    return v;
}
 
#define LOG_PROG( value, quantity ) \
    if( genesis::utils::Logging::kProgress > LOG_LEVEL_MAX ) ; \
    else if( genesis::utils::Logging::kProgress > genesis::utils::Logging::max_level() ) ; \
    else if( (long) genesis::utils::logging_progress_value(value) % \
        (((long) (quantity) * genesis::utils::Logging::report_percentage() / 100) > 0 ? \
        ((long) (quantity) * genesis::utils::Logging::report_percentage() / 100) : 1) != 0 ) ; \
    else genesis::utils::Logging().get(__FILE__, __LINE__, GENESIS_FUNC, genesis::utils::Logging::kProgress) << \
    (int) round(100.0 * (double) genesis::utils::logging_progress_value() / ((quantity) > 0 ? (quantity) : 1)) << "% "
 
// =============================================================================
//     Logging Details
// =============================================================================
 
struct LoggingDetails {
 
    LoggingDetails() = default;
 
    LoggingDetails(
        bool v_count, bool v_date, bool v_time, bool v_runtime, bool v_rundiff,
        bool v_file, bool v_line, bool v_function, bool v_level
    )
        : count( v_count )
        , date( v_date )
        , time( v_time )
        , runtime( v_runtime )
        , rundiff( v_rundiff )
        , file( v_file )
        , line( v_line )
        , function( v_function )
        , level( v_level )
    {}
 
    bool count = false;
 
    bool date = false;
 
    bool time = false;
 
    bool runtime = false;
 
    bool rundiff = false;
 
    bool file = false;
 
    bool line = false;
 
    bool function = false;
 
    bool level = false;
};
 
// =============================================================================
//     Logging
// =============================================================================
 
class Logging
{
public:
 
    // -------------------------------------------------------------------
    //     Class Functions
    // -------------------------------------------------------------------
 
    enum LoggingLevel {
        kNone = 0,
 
        kError,
 
        kWarning,
 
        kInfo,
 
        kProgress,
 
        kMessage,
 
        kMessage1,
 
        kMessage2,
 
        kMessage3,
 
        kMessage4,
 
        kDebug,
 
        kDebug1,
 
        kDebug2,
 
        kDebug3,
 
        kDebug4
    };
 
    Logging() {}
    ~Logging();
 
    // Logging is kind of singleton, its instances are only provided via the
    // get functions. do not allow other instances by blocking the copy
    // constructors and copy assignment
    Logging (const Logging&) {}
    Logging& operator = (const Logging&) = delete;
 
    // getter for the singleton instance of log, is called by the macros
    std::ostringstream& get (
        const std::string& file, const int line, const std::string& function,
        const LoggingLevel level
    );
    std::ostringstream& get (
        const std::string& file, const int line, const std::string& function,
        const LoggingLevel level, const LoggingDetails dets
    );
 
    // -------------------------------------------------------------------
    //     Logging Settings
    // -------------------------------------------------------------------
 
    // TODO make logging accept one file, and a setter for cout and for cerr
    // TODO allow different levels to be logged to different streams?!
 
    // methods to handle the output streams to write the log messages to
    static void log_to_stdout ();
    static void log_to_stream (std::ostream& os);
    static void log_to_file   (const std::string& fn);
    static void clear();
 
    static LoggingDetails details;
 
    static inline LoggingLevel max_level ()
    {
        return max_level_;
    }
    static void max_level (const LoggingLevel level);
 
    static inline int report_percentage ()
    {
        return report_percentage_;
    }
    static void report_percentage (const int percentage);
 
    // return a string representation for a log level
    static std::string level_to_string (const LoggingLevel level);
 
    static std::string debug_indent;
 
    // -------------------------------------------------------------------
    //     Static Wrappers
    // -------------------------------------------------------------------
 
    static inline void log_error (const std::string& msg)
    {
        LOG_ERR << msg;
    }
 
    static inline void log_warning (const std::string& msg)
    {
        LOG_WARN << msg;
    }
 
    static inline void log_info (const std::string& msg)
    {
        LOG_INFO << msg;
    }
 
    static inline void log_message (const std::string& msg)
    {
        LOG_MSG << msg;
    }
 
    static inline void log_message_1 (const std::string& msg)
    {
        LOG_MSG1 << msg;
    }
 
    static inline void log_message_2 (const std::string& msg)
    {
        LOG_MSG2 << msg;
    }
 
    static inline void log_message_3 (const std::string& msg)
    {
        LOG_MSG3 << msg;
    }
 
    static inline void log_message_4 (const std::string& msg)
    {
        LOG_MSG4 << msg;
    }
 
    static inline void log_debug (const std::string& msg)
    {
        LOG_DBG << msg;
    }
 
    static inline void log_debug_1 (const std::string& msg)
    {
        LOG_DBG1 << msg;
    }
 
    static inline void log_debug_2 (const std::string& msg)
    {
        LOG_DBG2 << msg;
    }
 
    static inline void log_debug_3 (const std::string& msg)
    {
        LOG_DBG3 << msg;
    }
 
    static inline void log_debug_4 (const std::string& msg)
    {
        LOG_DBG4 << msg;
    }
 
    // -------------------------------------------------------------------
    //     Internal Data Members
    // -------------------------------------------------------------------
 
protected:
    // storage for information needed during one invocation of a log
    std::ostringstream buff_;
    std::string        file_;
    int                line_ = 0;
    std::string        function_;
    LoggingLevel       level_ = {};
    LoggingDetails     details_ = {};
 
    // dynamic log level limit
    static LoggingLevel max_level_;
 
    // how often to report progress messages
    static int report_percentage_;
 
    // how many log calls were made so far
    static long    count_;
 
    // when was the last call to logging (used for time measurements)
    static clock_t last_clock_;
 
    // Arrays of streams that are used for output.
    // We separate normal output streams from file streams, so that the latter can be closed
    // properly. That is, we take normal ostream by reference, and hence do not manage them here,
    // but open/close/manage the lifetimes of file streams ourselves. Users can of course also
    // provide their own file streams and add them via log_to_stream, but we don't manage those then.
    static std::vector<std::ostream*> ostreams_;
    static std::vector<std::unique_ptr<std::ofstream>> fstreams_;
};
 
// =============================================================================
//     Logging Scope Level
// =============================================================================
 
class LoggingScopeLevel
{
public:
    explicit LoggingScopeLevel( Logging::LoggingLevel scope_level )
    {
        previous_level = Logging::max_level();
        Logging::max_level(scope_level);
    }
 
    ~LoggingScopeLevel()
    {
        Logging::max_level(previous_level);
    }
 
private:
    Logging::LoggingLevel previous_level;
};
 
// =============================================================================
//     Logging Progress
// =============================================================================
 
/*
 * This was a test to make LOG_PROG work with incrementing counters like
 *
 *     LOG_PROG(++progress, total) << "of something";
 *
 * but it is slow and dirty. If used, Logging().get(...) has to be expanded by a
 * std::string init parameters, that is used to initialize buff_.str(init).
 *
 * Also, the definition of LOG_PROG that was used for this is:
 *
 *     #define LOG_PROG(value, quantity) \
 *         if (genesis::utils::Logging::kProgress > LOG_LEVEL_MAX) ; \
 *         else if (genesis::utils::Logging::kProgress > genesis::utils::Logging::max_level()) ; \
 *         else LOG_PROG_FUNC(value, quantity, __FILE__, __LINE__, GENESIS_FUNC)
 * %
inline std::ostringstream& LOG_PROG_FUNC (const int value, const int quantity, const std::string& file, const int line, const std::string& function)
{
    static std::ostringstream trash;
    int base = quantity * Logging::report_percentage() / 100;
    if (value % (base > 0 ? base : 1) != 0) {
        trash.str("");
        return trash;
    } else {
        std::string init = std::to_string((int) round(100.0 * (double) value / quantity)) + "% ";
        return Logging().get(file, line, function, Logging::kProgress, Logging::details, init);
    }
}
*/
 
} // namespace utils
} // namespace genesis
 
#endif // include guard