logger.hpp

Go to the documentation of this file.

 
#ifndef ESO_UATOOLS_PROTOCOL_BASE_LOGGER_HPP
#define ESO_UATOOLS_PROTOCOL_BASE_LOGGER_HPP
 
#include <memory>
#include <string>
#include <string_view>
 
#include <fmt/format.h>
 
#include <eso/uatools/protocol/base/base.hpp>  // brings UATLOC, ThreadName, IsoTimeNow
 
namespace eso::uatools::protocol::base {

    enum class LogLevel : int {
        TRACE   = 0,
        DEBUG   = 10,
        INFO    = 20,
        WARNING = 30,
        ERROR   = 40,
        OFF     = 100,
    };

    class Logger {
        public:
            Logger() = default;
            virtual ~Logger() = default;
 
            Logger(const Logger&) = delete;
            Logger& operator=(const Logger&) = delete;
            Logger(Logger&&) = delete;
            Logger& operator=(Logger&&) = delete;

            virtual void Emit(LogLevel level, const std::string& message) = 0;

            virtual void Throw(const std::string& message);
 
            void SetLogLevel(LogLevel level) noexcept { m_level = level; }
            LogLevel GetLogLevel() const noexcept    { return m_level; }

            void Trace  (const std::string& m) { Emit(LogLevel::TRACE,   m); }
            void Debug  (const std::string& m) { Emit(LogLevel::DEBUG,   m); }
            void Info   (const std::string& m) { Emit(LogLevel::INFO,    m); }
            void Warning(const std::string& m) { Emit(LogLevel::WARNING, m); }
            void Error  (const std::string& m) { Emit(LogLevel::ERROR,   m); }
 
        protected:
            LogLevel m_level{LogLevel::INFO};
    };

    void InstallLogger(std::unique_ptr<Logger> logger) noexcept;

    Logger& Log();

    bool HasLogger() noexcept;

    std::unique_ptr<Logger> MakeStdoutLogger();

    std::unique_ptr<Logger> MakeNullLogger();

    std::string_view LogLevelName(LogLevel level) noexcept;

    inline std::string TraceExtra() {
        return {};
    }
    template <typename... Args>
    inline std::string TraceExtra(fmt::string_view fmt_str, Args&&... args) {
        return ": " + fmt::vformat(fmt_str, fmt::make_format_args(args...));
    }
 
}  // namespace eso::uatools::protocol::base

 
#define UAT_LOG_IMPL_(level_, fmt_str_, ...) \
    do { \
        auto& _uat_log = ::eso::uatools::protocol::base::Log(); \
        if (_uat_log.GetLogLevel() <= (level_)) { \
            _uat_log.Emit((level_), \
                UATLOC + ": " + \
                ::fmt::format( \
                    ::fmt::runtime(std::string(fmt_str_)) \
                    __VA_OPT__(,) __VA_ARGS__)); \
        } \
    } while (0)

#define UATTRACE(...) \
    do { \
        auto& _uat_log = ::eso::uatools::protocol::base::Log(); \
        if (_uat_log.GetLogLevel() <= ::eso::uatools::protocol::base::LogLevel::TRACE) { \
            _uat_log.Emit(::eso::uatools::protocol::base::LogLevel::TRACE, \
                UATLOC + ": " + std::string(__PRETTY_FUNCTION__) + \
                ::eso::uatools::protocol::base::TraceExtra(__VA_ARGS__)); \
        } \
    } while (0)
 
#define UATDEBUG(fmt_str, ...) \
    UAT_LOG_IMPL_(::eso::uatools::protocol::base::LogLevel::DEBUG,   fmt_str __VA_OPT__(,) __VA_ARGS__)
 
#define UATINFO(fmt_str, ...) \
    UAT_LOG_IMPL_(::eso::uatools::protocol::base::LogLevel::INFO,    fmt_str __VA_OPT__(,) __VA_ARGS__)
 
#define UATWARNING(fmt_str, ...) \
    UAT_LOG_IMPL_(::eso::uatools::protocol::base::LogLevel::WARNING, fmt_str __VA_OPT__(,) __VA_ARGS__)
 
#define UATERROR(fmt_str, ...) \
    UAT_LOG_IMPL_(::eso::uatools::protocol::base::LogLevel::ERROR,   fmt_str __VA_OPT__(,) __VA_ARGS__)
 
#define UATTHROW(fmt_str, ...) \
    do { \
        ::eso::uatools::protocol::base::Log().Throw( \
            UATLOC + ": " + \
            ::fmt::format( \
                ::fmt::runtime(std::string(fmt_str)) \
                __VA_OPT__(,) __VA_ARGS__)); \
    } while (0)

 
#endif  // ESO_UATOOLS_PROTOCOL_BASE_LOGGER_HPP