log.h

#pragma once
 
#include <fmt/format.h>
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <string>
#include <string_view>
#include <utility>
 
namespace pixelbullet::log
{
enum class Level
{
    Trace = 0,
    Info,
    Warn,
    Error,
    Critical,
    count
};
 
inline constexpr std::array<const char*, static_cast<std::size_t>(Level::count)> level_strings = { "TRACE", "INFO", "WARN", "ERROR",
                                                                                                   "CRITICAL" };
 
inline constexpr const char* to_string(const Level level) noexcept
{
    const std::size_t index = static_cast<std::size_t>(level);
    return index < level_strings.size() ? level_strings[index] : "UNKNOWN";
}
 
struct LogConfig
{
    std::filesystem::path root_directory;
    std::size_t retained_session_count = 20;
    bool allow_environment_override = true;
};
 
struct LogRecord
{
    std::string timestamp_iso8601;
    std::string elapsed;
    uint32_t process_id = 0;
    std::string thread_id;
    Level severity = Level::Info;
    std::string logger_name;
    std::string message;
};
 
class Logger
{
public:
    explicit Logger(std::string name);
 
    [[nodiscard]] const std::string& name() const
    {
        return name_;
    }
 
    template <typename... Args>
    void trace(fmt::format_string<Args...> fmt_str, Args&&... args) const
    {
        write(Level::Trace, fmt::format(fmt_str, std::forward<Args>(args)...));
    }
 
    template <typename... Args>
    void info(fmt::format_string<Args...> fmt_str, Args&&... args) const
    {
        write(Level::Info, fmt::format(fmt_str, std::forward<Args>(args)...));
    }
 
    template <typename... Args>
    void warn(fmt::format_string<Args...> fmt_str, Args&&... args) const
    {
        write(Level::Warn, fmt::format(fmt_str, std::forward<Args>(args)...));
    }
 
    template <typename... Args>
    void error(fmt::format_string<Args...> fmt_str, Args&&... args) const
    {
        write(Level::Error, fmt::format(fmt_str, std::forward<Args>(args)...));
    }
 
    template <typename... Args>
    void critical(fmt::format_string<Args...> fmt_str, Args&&... args) const
    {
        write(Level::Critical, fmt::format(fmt_str, std::forward<Args>(args)...));
    }
 
private:
    void write(Level level, std::string message) const;
 
    std::string name_;
};
} // namespace pixelbullet::log
 
namespace pixelbullet::logging
{
struct StartupInfo
{
    std::string binary_path;
    std::filesystem::path log_directory_override;
};
 
struct SessionMetadata
{
    std::string client_name;
    std::string client_version;
    std::string engine_name;
    std::string engine_version;
};
 
namespace names
{
inline constexpr std::string_view core = "core";
inline constexpr std::string_view core_app = "core.app";
inline constexpr std::string_view core_graphics = "core.graphics";
inline constexpr std::string_view core_image = "core.image";
inline constexpr std::string_view core_assets = "core.assets";
inline constexpr std::string_view core_shader = "core.shader";
inline constexpr std::string_view core_ui = "core.ui";
 
inline constexpr std::string_view client = "client";
 
inline constexpr std::string_view vulkan_validation = "vulkan.validation";
} // namespace names
 
void initialize(const StartupInfo& startup_info, const log::LogConfig& config = {});
void shutdown();
 
[[nodiscard]] bool is_initialized();
[[nodiscard]] std::shared_ptr<log::Logger> get(std::string_view name);
 
void update_session_metadata(const SessionMetadata& metadata);
 
[[nodiscard]] std::filesystem::path log_root();
[[nodiscard]] std::filesystem::path session_directory();
[[nodiscard]] std::filesystem::path latest_manifest_path();
} // namespace pixelbullet::logging
 
namespace pixelbullet::log
{
template <typename... Args>
void trace(fmt::format_string<Args...> fmt_str, Args&&... args)
{
    logging::get(logging::names::core)->trace(fmt_str, std::forward<Args>(args)...);
}
 
template <typename... Args>
void info(fmt::format_string<Args...> fmt_str, Args&&... args)
{
    logging::get(logging::names::core)->info(fmt_str, std::forward<Args>(args)...);
}
 
template <typename... Args>
void warn(fmt::format_string<Args...> fmt_str, Args&&... args)
{
    logging::get(logging::names::core)->warn(fmt_str, std::forward<Args>(args)...);
}
 
template <typename... Args>
void error(fmt::format_string<Args...> fmt_str, Args&&... args)
{
    logging::get(logging::names::core)->error(fmt_str, std::forward<Args>(args)...);
}
 
template <typename... Args>
void critical(fmt::format_string<Args...> fmt_str, Args&&... args)
{
    logging::get(logging::names::core)->critical(fmt_str, std::forward<Args>(args)...);
}
} // namespace pixelbullet::log