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/algorithm/string.hpp>
#include <boost/thread.hpp>
 
#include <expected>
#include <sstream>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  class Logger {
   public:
    static Logger& getInstance();
 
    class Severity {
     public:
      enum Value { trace, debug, info, warning, error };
 
      // NOLINTNEXTLINE(google-explicit-constructor)
      constexpr Severity(const Value& value) : _value(value) {}
 
      // NOLINTNEXTLINE(google-explicit-constructor)
      [[nodiscard]] constexpr operator Value() { return _value; }
 
      [[nodiscard]] constexpr std::string_view toString() const;
 
      [[nodiscard]] constexpr auto operator<=>(const Severity& other) const = default;
      [[nodiscard]] constexpr auto operator<=>(const Severity::Value& other) const { return _value <=> other; }
 
      constexpr static std::expected<Logger::Severity, std::string> fromString(const std::string& string);
 
     private:
      Value _value;
    };
 
    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{defaultSeverityFromEnv()};
 
    // 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(); }};
 
    static Severity defaultSeverityFromEnv();
 
    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;
  }
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  constexpr std::string_view Logger::Severity::toString() const {
    switch(_value) {
      case trace:
        return "trace";
      case debug:
        return "debug";
      case info:
        return "info";
      case warning:
        return "warning";
      case error:
        return "error";
    }
    std::unreachable();
  }
 
  /********************************************************************************************************************/
 
  constexpr std::expected<Logger::Severity, std::string> Logger::Severity::fromString(const std::string& string) {
    auto stringLower = boost::algorithm::to_lower_copy(std::string(string));
    if(stringLower == "trace") {
      return trace;
    }
    if(stringLower == "debug") {
      return debug;
    }
    if(stringLower == "info") {
      return info;
    }
    if(stringLower == "warning") {
      return warning;
    }
    if(stringLower == "error") {
      return error;
    }
    return std::unexpected("Valid values are: trace, debug, info, warning, error.");
  }
 
  /********************************************************************************************************************/
 
} // namespace ChimeraTK