logging.hpp

Go to the documentation of this file.

#pragma once
#include <iostream>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <thread>
#include <atomic>
#include <sstream>
#include <iomanip>

#define LOG(lvl)    logging::LogWriter<lvl>
#define TRACE   LOG(logging::Severity::trace)() << __FILE__ << ":" << __LINE__ << " "
#define DEBUG   LOG(logging::Severity::debug)()
#define INFO    LOG(logging::Severity::info)()
#define WARNING LOG(logging::Severity::warning)()
#define ERROR   LOG(logging::Severity::error)()
#define FATAL   LOG(logging::Severity::fatal)()

#define DEFAULT_LOGGING \
  auto default_sink = std::make_shared<logging::LogSinkPrinter>(); \
  logging::LoggerImpl::get().setOutput(std::static_pointer_cast<logging::LogSink>(default_sink));

namespace logging {
  enum Severity {
    fatal,
    error,
    warning,
    info,
    debug,
    trace
  };

  const std::string severity_lines[] = {"FATAL", "ERROR", "WARNING",
                                        "INFO", "DEBUG", "TRACE"};

  struct LogMessage {
    const std::chrono::high_resolution_clock::time_point _timestamp;
    const Severity _severity;
    const std::string _message;
    LogMessage(const std::chrono::high_resolution_clock::time_point t,
               const Severity                       s,
               const std::string                  & m) :
      _timestamp(t),
      _severity(s),
      _message(m) {};
  };

  struct LogSink {
    virtual void write(const LogMessage&& msg) = 0;
  };

  class LogSinkPrinter: public LogSink {
    std::string formatMessage(const LogMessage&& msg) const;
  public:
    void write(const LogMessage&& msg) override;
  };

  class LoggerImpl {
    std::queue<LogMessage> _messages;      
    std::mutex _mutex;                     
    std::condition_variable _cond;         
    std::unique_ptr<std::thread> _writer;  
    std::atomic_bool _running;             
    unsigned int _log_repeat;              
    std::weak_ptr<LogSink> _sink;          
    void writeOut();
  public:
    static LoggerImpl& get();              
    LoggerImpl(LoggerImpl const&) = delete;
    LoggerImpl(LoggerImpl&&) = delete;
    LoggerImpl& operator=(LoggerImpl const&) = delete;
    LoggerImpl& operator=(LoggerImpl&&) = delete;

    void log(const LogMessage&& msg);

    void setOutput(const std::shared_ptr<LogSink>& output);

  protected:
    LoggerImpl() :
      _messages(),
      _mutex(),
      _cond(),
      _writer(nullptr),
      _running(ATOMIC_FLAG_INIT),
      _log_repeat(1)
    {}

    ~LoggerImpl() {
      if (_writer) {
        while (!_messages.empty() && !_sink.expired()) { _cond.notify_one(); }
        _running = false;
        _writer->detach();
        _cond.notify_one();
      }
    }
  };

  template <Severity s>
  class LogWriter {
    std::stringstream _message;
    const std::chrono::high_resolution_clock::time_point _timestamp;
  public:
    LogWriter() : _timestamp(std::chrono::high_resolution_clock::now()) {};
    ~LogWriter() {
      LoggerImpl::get().log(LogMessage(_timestamp, s, _message.str()));
    };

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

}