Log.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_LOGGING_LOG_HPP_
#define GALAXY_LOGGING_LOG_HPP_
 
#include <filesystem>
#include <source_location>
#include <stacktrace>
 
#include <BS_thread_pool.hpp>
#include <entt/locator/locator.hpp>
#include <magic_enum/magic_enum.hpp>
 
#include "galaxy/logging/LogLevel.hpp"
#include "galaxy/logging/Sink.hpp"
#include "galaxy/utils/StringUtils.hpp"
 
#define GALAXY_INFO                     galaxy::LogLevel::INFO
#define GALAXY_WARN                     galaxy::LogLevel::WARNING
#define GALAXY_ERROR                    galaxy::LogLevel::ERROR
#define GALAXY_FATAL                    galaxy::LogLevel::FATAL
#define GALAXY_LOG_SET_MIN_LEVEL(level) entt::locator<galaxy::Log>::value().set_min_level<level>()
#define GALAXY_ADD_SINK(sink, ...)      entt::locator<galaxy::Log>::value().add_sink<sink>(__VA_ARGS__)
#define GALAXY_LOG(level, msg, ...)     entt::locator<galaxy::Log>::value().log<level>(std::stacktrace::current(), std::source_location::current(), msg __VA_OPT__(, ) __VA_ARGS__)
 
namespace galaxy
{
    class Log final
    {
    public:
        Log() noexcept;
 
        ~Log() noexcept;
 
        template<std::derived_from<Sink> SinkTo, typename... Args>
        [[maybe_unused]]
        SinkTo& add_sink(Args&&... args);
 
        template<LogLevel level>
        void set_min_level() noexcept;
 
        template<LogLevel level, typename... MsgInputs>
        void log(const std::stacktrace& trace, const std::source_location& loc, std::string_view message, const MsgInputs&... args);
 
    private:
        Log(const Log&) = delete;
 
        Log(Log&&) = delete;
 
        Log& operator=(const Log&) = delete;
 
        Log& operator=(Log&&) = delete;
 
    private:
        LogLevel m_min_level;
 
        std::vector<std::unique_ptr<Sink>> m_sinks;
 
        std::mutex m_mutex;
    };
 
    template<std::derived_from<Sink> SinkTo, typename... Args>
    inline SinkTo& Log::add_sink(Args&&... args)
    {
        m_sinks.push_back(std::make_unique<SinkTo>(std::forward<Args>(args)...));
        SinkTo* ptr = dynamic_cast<SinkTo*>(m_sinks.back().get());
        return *ptr;
    }
 
    template<LogLevel level>
    inline void Log::set_min_level() noexcept
    {
        m_min_level = level;
    }
 
    template<LogLevel level, typename... MsgInputs>
    inline void Log::log(const std::stacktrace& trace, const std::source_location& loc, std::string_view message, const MsgInputs&... args)
    {
        auto& tp = entt::locator<BS::priority_thread_pool>::value();
        tp.detach_task(
            [this, trace = trace, loc = loc, message = message, ... args = args]() {
                if (level >= m_min_level)
                {
                    // clang-format off
                    LogMessage lm
                    {
                        .colour = galaxy::get_loglevel_colour<level>(),
                        .level = level,
                        .time    = std::format("{0:%r}", std::chrono::zoned_time {std::chrono::current_zone(), std::chrono::system_clock::now()}.get_local_time()),
                        .file     = std::filesystem::path(loc.file_name()).filename().string(),
                        .line    = loc.line(),
                        .message = std::vformat(message, std::make_format_args(args...)),
                        .trace = std::to_string(trace)
                    };
                    // clang-format on
 
                    // Send message to all sinks.
                    const std::lock_guard<std::mutex> lock(m_mutex);
 
                    for (const auto& sink : m_sinks)
                    {
                        sink->sink(lm);
                    }
 
                    // Then throw error if its FATAL.
                    if constexpr (level == LogLevel::FATAL)
                    {
                        throw std::runtime_error(lm.trace);
                    }
                }
            },
            BS::pr::lowest
        );
    }
} // namespace galaxy
 
#endif