Logger.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include <ChimeraTK/cppext/future_queue.hpp>
 
#include <boost/thread.hpp>
 
#include <sstream>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  class Logger {
   public:
    static Logger& getInstance();
 
    enum class Severity { trace, debug, info, warning, error };
 
    void setMinSeverity(Severity minSeverity) { _minSeverity = minSeverity; }
 
    class StreamProxy : public std::ostream {
     public:
      StreamProxy(Logger* logger, Severity severity, std::string context);
      ~StreamProxy() override;
 
     private:
      std::stringbuf _buf;
      Severity _severity;
      std::string _context;
      Logger& _logger;
    };
 
    StreamProxy getStream(Severity severity, std::string context);
 
    ~Logger();
 
   private:
    Logger() = default;
 
    static std::shared_ptr<Logger>& getSharedPtr();
 
    void log(Severity severity, std::string context, std::string message) noexcept;
 
    // The mainLoop() is executed in a dedicated thread waits for incoming log messages and prints them
    void mainLoop();
 
    // Convert Severity to string
    static std::string severityToString(Severity severity);
 
    // Struct with all arguments of log(), to be placed on to the _messageQueue
    struct LogMessage {
      Severity severity{Severity::info};
      std::string context;
      std::string text;
    };
 
    // This queue is filled in log() and read in mainLoop()
    cppext::future_queue<LogMessage> _messageQueue{10};
 
    // Minimum severity to be sent to the queue. This allows filtering lower severity messages at sender side, even
    // before the message text has been (fully) composed.
    std::atomic<Severity> _minSeverity{Severity::info};
 
    // Thread executing mainLoop().
    // Note: The thread must be started only after all other data members have been initialised, so this line must
    // come last (or the thread must be only started in the constructor body).
    boost::thread _mainLoopThread{[this] { mainLoop(); }};
 
    friend class Application;
  };
 
  /********************************************************************************************************************/
 
  inline Logger::StreamProxy logger(Logger::Severity severity, std::string context) {
    return Logger::getInstance().getStream(severity, std::move(context));
  }
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  inline Logger& Logger::getInstance() {
    return *getSharedPtr();
  }
 
  /********************************************************************************************************************/
 
  inline std::shared_ptr<Logger>& Logger::getSharedPtr() {
    static std::shared_ptr<Logger> instance(new Logger());
    return instance;
  }
 
  /********************************************************************************************************************/
 
} // namespace ChimeraTK