logger.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
#include <fmt/format.h>
 
// FNDLOC: defined in <ifw/fnd/defs/base.hpp>, used by every FND* macro
// below. NOT included here because base.hpp itself includes this header
// (so its inline helpers can use FND* macros). Consumers should include
// base.hpp instead of this header — it transitively pulls everything in.
 
namespace ifw::fnd {
 
    // Conventional logger name; kept for backwards compatibility with code
    // that wants to embed it in messages or pass it to a concrete backend
    // (e.g. when an InstallLogger() implementation routes to a named
    // logger in CII or log4cplus).
    static constexpr const char* IFW_FND_LOGGER_NAME = "ifwfnd";

    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);

            virtual std::vector<std::string> ListSources() const {
                return {};
            }
 
            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...));
    }

    class ScopedTracer {
    public:
        ScopedTracer(std::string location,
                     std::string extra) noexcept;
        ~ScopedTracer();
 
        ScopedTracer(const ScopedTracer&) = delete;
        ScopedTracer& operator=(const ScopedTracer&) = delete;
        ScopedTracer(ScopedTracer&&) = delete;
        ScopedTracer& operator=(ScopedTracer&&) = delete;
 
    private:
        const std::chrono::steady_clock::time_point m_entry;
        const std::string m_location;
        const std::string m_extra;
        const bool m_active;  
    };
 
}  // namespace ifw::fnd
 
// FNDLOC is pulled in via the base.hpp include above. The FND* macros
// below use it.

 
#define FND_LOG_IMPL_(level_, fmt_str_, ...) \
    do { \
        auto& _fnd_log = ::ifw::fnd::Log(); \
        if (_fnd_log.GetLogLevel() <= (level_)) { \
            _fnd_log.Emit((level_), \
                FNDLOC + ": " + \
                ::fmt::format( \
                    ::fmt::runtime(std::string(fmt_str_)) \
                    __VA_OPT__(,) __VA_ARGS__)); \
        } \
    } while (0)

#define FND_TRACE_NAME_(line) _fnd_trace_##line
#define FND_TRACE_NAME(line) FND_TRACE_NAME_(line)
 
#define FNDTRACE(...) \
    [[maybe_unused]] ::ifw::fnd::ScopedTracer FND_TRACE_NAME(__LINE__) { \
        (::ifw::fnd::HasLogger() && \
         ::ifw::fnd::Log().GetLogLevel() <= ::ifw::fnd::LogLevel::TRACE) \
            ? (FNDLOC + ": " + std::string(__PRETTY_FUNCTION__)) \
            : std::string{}, \
        (::ifw::fnd::HasLogger() && \
         ::ifw::fnd::Log().GetLogLevel() <= ::ifw::fnd::LogLevel::TRACE) \
            ? ::ifw::fnd::TraceExtra(__VA_ARGS__) \
            : std::string{} \
    }
 
#define FNDDEBUG(fmt_str, ...) \
    FND_LOG_IMPL_(::ifw::fnd::LogLevel::DEBUG,   fmt_str __VA_OPT__(,) __VA_ARGS__)
 
#define FNDINFO(fmt_str, ...) \
    FND_LOG_IMPL_(::ifw::fnd::LogLevel::INFO,    fmt_str __VA_OPT__(,) __VA_ARGS__)
 
#define FNDWARNING(fmt_str, ...) \
    FND_LOG_IMPL_(::ifw::fnd::LogLevel::WARNING, fmt_str __VA_OPT__(,) __VA_ARGS__)
 
#define FNDERROR(fmt_str, ...) \
    FND_LOG_IMPL_(::ifw::fnd::LogLevel::ERROR,   fmt_str __VA_OPT__(,) __VA_ARGS__)
 
#define FNDTHROW(fmt_str, ...) \
    do { \
        ::ifw::fnd::Log().Throw( \
            FNDLOC + ": " + \
            ::fmt::format( \
                ::fmt::runtime(std::string(fmt_str)) \
                __VA_OPT__(,) __VA_ARGS__)); \
    } while (0)