logger.hpp

 
#pragma once
 
#include <array>
#include <cstdint>
#include <iostream>
#include <memory>
#include <mutex>
#include <sstream>
#include <string>
#include <thread>
#include <unordered_map>
#include <utility>
 
#include <rapidsmpf/config.hpp>
#include <rapidsmpf/utils/misc.hpp>
 
namespace rapidsmpf {
 
class Logger : public std::enable_shared_from_this<Logger> {
  public:
    enum class LOG_LEVEL : std::uint32_t {
        NONE = 0,  
        PRINT,  
        WARN,  
        INFO,  
        DEBUG,  
        TRACE  
    };
 
    static constexpr std::array<char const*, 6> LOG_LEVEL_NAMES{
        "NONE", "PRINT", "WARN", "INFO", "DEBUG", "TRACE"
    };
 
    static constexpr char const* level_name(LOG_LEVEL level) {
        auto index = static_cast<std::size_t>(level);
        return index < LOG_LEVEL_NAMES.size() ? LOG_LEVEL_NAMES[index] : "UNKNOWN";
    }
 
    [[nodiscard]] static std::shared_ptr<Logger> create(
        LOG_LEVEL level = LOG_LEVEL::WARN, std::string name = "unknown"
    );
 
    [[nodiscard]] static std::shared_ptr<Logger> from_options(config::Options options);
 
    virtual ~Logger() noexcept = default;
 
    // `Logger` is owned exclusively through `std::shared_ptr`. Use `create()`
    // to construct instances.
    Logger(Logger const&) = delete;
    Logger& operator=(Logger const&) = delete;
    Logger(Logger&&) = delete;
    Logger& operator=(Logger&&) = delete;
 
    LOG_LEVEL verbosity_level() const {
        return level_;
    }
 
    void set_name(std::string name);
 
    template <typename... Args>
    void log(LOG_LEVEL level, Args const&... args) {
        if (static_cast<std::uint32_t>(level_) < static_cast<std::uint32_t>(level)) {
            return;
        }
        std::ostringstream ss;
        (ss << ... << args);
        do_log(level, std::move(ss));
    }
 
    template <typename... Args>
    void print(Args const&... args) {
        log(LOG_LEVEL::PRINT, std::forward<Args const&>(args)...);
    }
 
    template <typename... Args>
    void warn(Args const&... args) {
        log(LOG_LEVEL::WARN, std::forward<Args const&>(args)...);
    }
 
    template <typename... Args>
    void info(Args const&... args) {
        log(LOG_LEVEL::INFO, std::forward<Args const&>(args)...);
    }
 
    template <typename... Args>
    void debug(Args const&... args) {
        log(LOG_LEVEL::DEBUG, std::forward<Args const&>(args)...);
    }
 
    template <typename... Args>
    void trace(Args const&... args) {
        log(LOG_LEVEL::TRACE, std::forward<Args const&>(args)...);
    }
 
  protected:
    Logger(LOG_LEVEL level, std::string name);
 
    virtual std::uint32_t get_thread_id() {
        auto const tid = std::this_thread::get_id();
 
        // To avoid large IDs, we map the thread ID to an unique counter.
        auto const [name, inserted] =
            thread_id_names.insert({tid, thread_id_names_counter});
        if (inserted) {
            ++thread_id_names_counter;
        }
        return name->second;
    }
 
    virtual void do_log(LOG_LEVEL level, std::ostringstream&& ss) {
        std::lock_guard<std::mutex> lock(mutex_);
        std::ostringstream full_log_msg;
        full_log_msg << "[" << name_ << ":" << level_name(level) << ":" << get_thread_id()
                     << ":" << Clock::now() << "] " << ss.str();
        std::cout << full_log_msg.str() << std::endl;
    }
 
  private:
    std::mutex mutex_;
    LOG_LEVEL const level_;
    std::string name_;
 
    std::uint32_t thread_id_names_counter{0};
 
    std::unordered_map<std::thread::id, std::uint32_t> thread_id_names;
};
 
}  // namespace rapidsmpf