Logger.hpp

Go to the documentation of this file.

/**
 * @file Logger.hpp
 * @author Alexandre Plateau ([email protected])
 * @brief Internal logger
 * @date 2024-08-30
 *
 * @copyright Copyright (c) 2024-2025)
 */
#ifndef ARK_LOGGER_HPP
#define ARK_LOGGER_HPP
 
#include <iostream>
#include <fmt/format.h>
 
#include <string>
#include <chrono>
#include <vector>
#include <unordered_map>
#include <fmt/color.h>
 
namespace Ark::internal
{
    class Logger
    {
    public:
        /**
         * @brief Construct a new Logger object
         *
         * @param name the pass name, used for logging
         * @param debug_level debug level
         */
        Logger(std::string name, unsigned debug_level);
 
        [[nodiscard]] inline unsigned debugLevel() const { return m_debug; }
 
        [[nodiscard]] inline bool shouldInfo() const { return m_debug >= 1; }
        [[nodiscard]] inline bool shouldDebug() const { return m_debug >= 2; }
        [[nodiscard]] inline bool shouldTrace() const { return m_debug >= 3; }
 
        /**
         * @brief Write an info level log using fmtlib
         * @tparam Args
         * @param fmt format string
         * @param args
         */
        template <typename... Args>
        void info(const char* fmt, Args&&... args)
        {
            if (shouldInfo())
                fmt::println(
                    "{} [{}] {}",
                    fmt::styled("INFO ", fmt::fg(fmt::color::cornflower_blue)),
                    fmt::styled(m_name, fmt::fg(m_pass_color)),
                    fmt::vformat(fmt, fmt::make_format_args(args...)));
        }
 
        /**
         * @brief Write a debug level log using fmtlib
         * @tparam Args
         * @param fmt format string
         * @param args
         */
        template <typename... Args>
        void debug(const char* fmt, Args&&... args)
        {
            if (shouldDebug())
                fmt::println(
                    "{} [{}] {}",
                    fmt::styled("DEBUG", fmt::fg(fmt::color::pale_violet_red)),
                    fmt::styled(m_name, fmt::fg(m_pass_color)),
                    fmt::vformat(fmt, fmt::make_format_args(args...)));
        }
 
        inline void traceStart(std::string&& trace_name)
        {
            m_trace_starts[trace_name] = std::chrono::high_resolution_clock::now();
            m_active_traces.push_back(trace_name);
        }
 
        inline void traceEnd()
        {
            std::string trace_name = m_active_traces.back();
            m_active_traces.pop_back();
 
            const auto time = std::chrono::high_resolution_clock::now();
            const std::chrono::duration<double, std::milli> ms_double = time - m_trace_starts[trace_name];
            trace("{} took {:.3f}ms", trace_name, ms_double.count());
        }
 
        /**
         * @brief Write a trace level log using fmtlib
         * @tparam Args
         * @param fmt format string
         * @param args
         */
        template <typename... Args>
        void trace(const char* fmt, Args&&... args)
        {
            if (shouldTrace())
                fmt::println(
                    "{} [{}] {}",
                    fmt::styled("TRACE", fmt::fg(fmt::color::golden_rod)),
                    fmt::styled(m_name, fmt::fg(m_pass_color)),
                    fmt::vformat(fmt, fmt::make_format_args(args...)));
        }
 
    private:
        unsigned m_debug;
        std::string m_name;
        fmt::color m_pass_color;
        std::unordered_map<std::string, std::chrono::time_point<std::chrono::high_resolution_clock>> m_trace_starts;
        std::vector<std::string> m_active_traces;
    };
}
 
#endif  // ARK_LOGGER_HPP