logger.h

Go to the documentation of this file.

#ifndef META_LOGGER_H_
#define META_LOGGER_H_

#include <chrono>
#include <functional>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <vector>

namespace meta
{

namespace logging
{

class logger
{
  public:
    enum class severity_level
    {
        progress,
        trace,
        debug,
        info,
        warning,
        error,
        fatal
    };

    static std::string severity_string(severity_level sev)
    {
        switch (sev)
        {
            case severity_level::progress:
                return "progress";
            case severity_level::trace:
                return "trace";
            case severity_level::debug:
                return "debug";
            case severity_level::info:
                return "info";
            case severity_level::warning:
                return "warning";
            case severity_level::error:
                return "error";
            case severity_level::fatal:
                return "fatal";
            default:
                return "unknown";
        }
    }

    class log_line
    {
      public:
        log_line(logger& log, severity_level sev, size_t line,
                 const std::string& file)
            : log_(log), sev_(sev), line_(line), file_(file)
        {
            /* nothing */
        }

        static log_line& endlg(log_line& logline)
        {
            logline.stream_.flush();
            logline.write_to_sinks();
            return logline;
        }

        log_line& operator<<(log_line& (*fn)(log_line&))
        {
            return (*fn)(*this);
        }

        template <class T>
        log_line& operator<<(const T& to_write)
        {
            stream_ << to_write;
            return *this;
        }

        void write_to_sinks()
        {
            log_.write_to_sinks(*this);
        }

        std::string str() const
        {
            return stream_.str();
        }

        severity_level severity() const
        {
            return sev_;
        }

        const std::string& file() const
        {
            return file_;
        }

        size_t line() const
        {
            return line_;
        }

      private:
        std::stringstream stream_;

        logger& log_;

        severity_level sev_;

        size_t line_;

        std::string file_;
    };

    class sink
    {
      public:
        using formatter_func = std::function<std::string(const log_line&)>;

        using filter_func = std::function<bool(const log_line&)>;

        sink(std::ostream& stream, const filter_func& filter =
            [](const log_line&) { return true; },
            const formatter_func& formatter = &default_formatter)
            : stream_(stream), formatter_(formatter), filter_(filter)
        {
            /* nothing */
        }

        sink(std::ostream& stream, logger::severity_level sev,
             const formatter_func& formatter = &default_formatter)
            : stream_(stream),
              formatter_(formatter),
              filter_([sev](const log_line& ll)
                  { return ll.severity() >= sev; })
        {
            // nothing
        }

        void write(const log_line& line)
        {
            if (filter_)
                if (!filter_(line))
                    return;
            if (formatter_)
                stream_ << formatter_(line);
            else
                stream_ << line.str();
            stream_ << std::flush;
        }

        static std::string default_formatter(const log_line& line)
        {
            namespace sc = std::chrono;

            auto time = sc::system_clock::now();
            auto since_epoch = time.time_since_epoch();
            auto unix_time = sc::duration_cast<sc::seconds>(since_epoch);

            std::stringstream ss;
            ss << unix_time.count();
            ss << ": ";

            std::stringstream sev;
            sev << "[" << severity_string(line.severity()) << "]";
            ss << std::setw(10) << std::left << sev.str();

            ss << " ";
            ss << line.str();
            ss << " ";

            ss << "(" << line.file() << ":" << line.line() << ")";
            ss << std::endl;
            return ss.str();
        }

      private:
        std::ostream& stream_;

        formatter_func formatter_;

        filter_func filter_;
    };

    void add_sink(const sink& s)
    {
        sinks_.push_back(s);
    }

    void add_sink(sink&& s)
    {
        sinks_.emplace_back(std::move(s));
    }

    void write_to_sinks(const log_line& line)
    {
        for (sink& s : sinks_)
            s.write(line);
    }

  private:
    std::vector<sink> sinks_;
};

inline logger& get_logger()
{
    static logger log;
    return log;
}

inline void add_sink(const logger::sink& s)
{
    get_logger().add_sink(s);
}

inline void add_sink(logger::sink&& s)
{
    get_logger().add_sink(std::move(s));
}

inline void set_cerr_logging(logging::logger::severity_level sev
                             = logging::logger::severity_level::trace)
{
    // separate logging for progress output
    add_sink({std::cerr, [](const logger::log_line& ll) {
        return ll.severity() == logger::severity_level::progress;
    }, [](const logger::log_line& ll) {
        return " " + ll.str();
    }});

    add_sink({std::cerr, sev});
}
}
}

#define LOG(sev)                                                               \
    logging::logger::log_line(logging::get_logger(),                           \
                              logging::logger::severity_level::sev, __LINE__,  \
                              __FILE__)
#define ENDLG logging::logger::log_line::endlg
#define LOG_FUNCTION_START()                                                   \
    LOG(trace) << "entering " << __func__ << "()" << ENDLG
#endif