logging.hpp

Go to the documentation of this file.

// Copyright (c) 2021 MIT Digital Currency Initiative,
//                    Federal Reserve Bank of Boston
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef OPENCBDC_TX_SRC_COMMON_LOGGING_H_
#define OPENCBDC_TX_SRC_COMMON_LOGGING_H_
 
#include <chrono>
#include <cstdint>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <memory>
#include <mutex>
#include <optional>
#include <sstream>
 
namespace cbdc::logging {
    class null_stream : public std::ostream {
      public:
        null_stream();
 
        template<typename T>
        auto operator<<(const T& /* unused */) -> null_stream& {
            return *this;
        }
        auto operator<<(const T& /* unused */) -> null_stream& {…}
    };
    class null_stream : public std::ostream {…};
 
    enum class log_level : uint8_t {
        trace,
        debug,
        info,
        warn,
        error,
        fatal
    };
    enum class log_level : uint8_t {…};
 
    class log {
      public:
        explicit log(log_level level,
                     bool use_stdout = true,
                     std::unique_ptr<std::ostream> logfile
                     = std::make_unique<null_stream>());
 
        void set_stdout_enabled(bool stdout_enabled);
 
        void set_logfile(std::unique_ptr<std::ostream> logfile);
 
        void set_loglevel(log_level level);
 
        static void flush();
 
        template<typename... Targs>
        void trace(Targs&&... args) {
            write_log_statement(log_level::trace,
                                std::forward<Targs>(args)...);
        }
        void trace(Targs&&... args) {…}
 
        template<typename... Targs>
        void debug(Targs&&... args) {
            write_log_statement(log_level::debug,
                                std::forward<Targs>(args)...);
        }
        void debug(Targs&&... args) {…}
 
        template<typename... Targs>
        void info(Targs&&... args) {
            write_log_statement(log_level::info, std::forward<Targs>(args)...);
        }
        void info(Targs&&... args) {…}
 
        template<typename... Targs>
        void warn(Targs&&... args) {
            write_log_statement(log_level::warn, std::forward<Targs>(args)...);
        }
        void warn(Targs&&... args) {…}
 
        template<typename... Targs>
        void error(Targs&&... args) {
            write_log_statement(log_level::error,
                                std::forward<Targs>(args)...);
        }
        void error(Targs&&... args) {…}
 
        template<typename... Targs>
        [[noreturn]] void fatal(Targs&&... args) {
            write_log_statement(log_level::fatal,
                                std::forward<Targs>(args)...);
            exit(EXIT_FAILURE);
        }
        [[noreturn]] void fatal(Targs&&... args) {…}
 
        [[nodiscard]] auto get_log_level() const -> log_level;
 
      private:
        bool m_stdout{true};
        log_level m_loglevel{};
        std::mutex m_stream_mut{};
        std::unique_ptr<std::ostream> m_logfile;
 
        auto static to_string(log_level level) -> std::string;
        static void write_log_prefix(std::stringstream& ss, log_level level);
        template<typename... Targs>
        void write_log_statement(log_level level, Targs&&... args) {
            if(m_loglevel <= level) {
                std::stringstream ss;
                write_log_prefix(ss, level);
                ((ss << " " << args), ...);
                ss << "\n";
                auto formatted_statement = ss.str();
                const std::lock_guard<std::mutex> lock(m_stream_mut);
                if(m_stdout) {
                    std::cout << formatted_statement;
                }
                *m_logfile << formatted_statement;
            }
        }
    };
    class log {…};
 
    auto parse_loglevel(const std::string& level) -> std::optional<log_level>;
}
 
#endif // OPENCBDC_TX_SRC_COMMON_LOGGING_H_