utils/logger.h

Go to the documentation of this file.

#ifndef UTILS_LOGGER_H
#define UTILS_LOGGER_H

#include "utils/timeutils.h"

#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <execinfo.h>
#include <iostream>
#include <sstream>
#include <vector>

#ifndef LOG_LEVEL
#ifdef NDEBUG
#define LOG_LEVEL 2
#else // NDEBUG
#define LOG_LEVEL 3
#endif // NDEBUG
#endif // LOG_LEVEL

#ifndef LOG_PREFIX
#define LOG_PREFIX "%a %b %d %X"
#endif // DEBUG_PRFIX

#ifndef LOG_ABORT
#ifdef MPI_VERSION
#define LOG_ABORT MPI_Abort(MPI_COMM_WORLD, -1)
#else // MPI_VERSION
#define LOG_ABORT abort()
#endif // MPI_VERSION
#endif // LOG_ABORT

#ifndef BACKTRACE_SIZE
#define BACKTRACE_SIZE 50
#endif // BACKTRACE_SIZE

namespace utils
{

class Logger
{
public:
        enum DebugType {
                DEBUG,
                INFO,
                WARNING,
                ERROR
        };
private:
        struct Stream {
                DebugType type;
                int rank;
                int ref;
                std::stringstream buffer;
                bool space;

                Stream(DebugType t, int r)
                        : type(t), rank(r), ref(1),
                        buffer(std::stringstream::out),
                        space(true) { }
        } *stream;
public:
        Logger(DebugType t, int rank)
                : stream(new Stream(t, rank))
        {
                stream->buffer << utils::TimeUtils::timeAsString(LOG_PREFIX);

                switch (t) {
                case DEBUG:
                        stream->buffer << ", Debug: ";
                        break;
                case INFO:
                        stream->buffer << ", Info:  ";
                        break;
                case WARNING:
                        stream->buffer << ", Warn:  ";
                        break;
                case ERROR:
                        stream->buffer << ", Error: ";
                        break;
                }
        }
        Logger(const Logger& o) : stream(o.stream) { stream->ref++; };
        ~Logger()
        {
                if (!--stream->ref) {
                        if (stream->rank == 0) {
                                if (stream->type == INFO)
                                        std::cout << stream->buffer.str() << std::endl;
                                else
                                        std::cerr << stream->buffer.str() << std::endl;
                        }

                        if (stream->type == ERROR) {
                                delete stream;
                                stream = 0L;    // Avoid double free if LOG_ABORT does
                                                                // does not exit the program

                                // Backtrace
                                if (BACKTRACE_SIZE > 0) {
                                        void *buffer[BACKTRACE_SIZE];
                                        int nptrs = backtrace(buffer, BACKTRACE_SIZE);
                                        char** strings = backtrace_symbols(buffer, nptrs);

                                        // Buffer output to avoid interlacing with other processes
                                        std::stringstream outputBuffer;
                                        outputBuffer << "Backtrace:" << std::endl;
                                        for (int i = 0; i < nptrs; i++)
                                                outputBuffer << strings[i] << std::endl;
                                        free(strings);

                                        // Write backtrace to stderr
                                        std::cerr << outputBuffer.str() << std::flush;
                                }

                                LOG_ABORT;
                        }

                        delete stream;
                }
        }

        Logger &operator=(const Logger& other)
        {
                if (this != &other) {
                        Logger copy(other);
                        std::swap(stream, copy.stream);
                }
                return *this;
        }


        /********* Space handling *********/

        Logger &space()
        {
                stream->space = true;
                stream->buffer << ' ';
                return *this;
        }
        Logger &nospace()
        {
                stream->space = false;
                return *this;
        }
        Logger &maybeSpace()
        {
                if (stream->space)
                        stream->buffer << ' ';
                return *this;
        }

        template<typename T>
        Logger &operator<<(T t)
        {
                stream->buffer << t;
                return maybeSpace();
        }

        Logger &operator<<(const std::string& t)
        {
                stream->buffer << '"' << t << '"';
                return maybeSpace();
        }

        Logger &operator<<(std::string& t)
        {
                stream->buffer << '"' << t << '"';
                return maybeSpace();
        }

        Logger &operator<<(std::ostream& (*func)(std::ostream&))
        {
                stream->buffer << func;
                return *this; // No space in this case
        }

        Logger &operator<<(Logger& (*func)(Logger&))
        {
                func(*this);
                return *this;
        }
};

inline Logger& space(Logger &logger)
{
        return logger.space();
}

inline Logger& nospace(Logger &logger)
{
        return logger.nospace();
}

class NoLogger
{
public:
        NoLogger() {};
        ~NoLogger() {};

        template<typename T>
        NoLogger &operator<<(const T&)
        {
                return *this;
        }

        NoLogger &operator<<(std::ostream& (*func)(std::ostream&))
        {
                return *this;
        }

        NoLogger &operator<<(Logger& (*func)(Logger&))
        {
                return *this;
        }
};

template <typename T>
inline Logger &operator<<(Logger debug, const std::vector<T> &list)
{
        debug.nospace() << '(';
        for (size_t i = 0; i < list.size(); i++) {
                if (i)
                        debug << ", ";
                debug << list[i];
        }
        debug << ')';

        return debug.space();
}

}

// Define global functions

inline
utils::Logger logError()
{
        return utils::Logger(utils::Logger::ERROR, 0);
}

#if LOG_LEVEL >= 1

inline
utils::Logger logWarning( int rank = 0 )
{
        return utils::Logger(utils::Logger::WARNING, rank);
}
#else // LOG_LEVEL >= 1

inline
utils::NoLogger logWarning( int = 0 ) { return utils::NoLogger(); }
#endif // LOG_LEVEL >= 1

#if LOG_LEVEL >= 2

inline
utils::Logger logInfo( int rank = 0 )
{
        return utils::Logger(utils::Logger::INFO, rank);
}
#else // LOG_LEVEL >= 2

inline
utils::NoLogger logInfo( int = 0 ) { return utils::NoLogger(); }
#endif // LOG_LEVEL >= 2

#if LOG_LEVEL >= 3

inline
utils::Logger logDebug( int rank = 0 )
{
        return utils::Logger(utils::Logger::DEBUG, rank);
}
#else // LOG_LEVEL >= 3

inline
utils::NoLogger logDebug( int = 0 ) { return utils::NoLogger(); }
#endif // LOG_LEVEL >= 3


// Use for variables unused when compiling with NDEBUG
#ifdef NDEBUG
#define NDBG_UNUSED(x) ((void) x)
#else // NDEBUG
#define NDBG_UNUSED(x)
#endif // NDEBUG

#endif // UTILS_LOGGER_H