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<size_t>(Level::count)> level_strings = { "TRACE", "INFO", "WARN", "ERROR",
                                                                                              "CRITICAL" };
 
inline constexpr const char* ToString(Level level)
{
    return level_strings[static_cast<size_t>(level)];
}
 
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& GetName() const
    {
        return name_;
    }
 
    template <typename... Args>
    void Trace(fmt::format_string<Args...> fmtStr, Args&&... args) const
    {
        Write(Level::Trace, fmt::format(fmtStr, std::forward<Args>(args)...));
    }
 
    template <typename... Args>
    void Info(fmt::format_string<Args...> fmtStr, Args&&... args) const
    {
        Write(Level::Info, fmt::format(fmtStr, std::forward<Args>(args)...));
    }
 
    template <typename... Args>
    void Warn(fmt::format_string<Args...> fmtStr, Args&&... args) const
    {
        Write(Level::Warn, fmt::format(fmtStr, std::forward<Args>(args)...));
    }
 
    template <typename... Args>
    void Error(fmt::format_string<Args...> fmtStr, Args&&... args) const
    {
        Write(Level::Error, fmt::format(fmtStr, std::forward<Args>(args)...));
    }
 
    template <typename... Args>
    void Critical(fmt::format_string<Args...> fmtStr, Args&&... args) const
    {
        Write(Level::Critical, fmt::format(fmtStr, std::forward<Args>(args)...));
    }
 
private:
    void Write(Level level, std::string message) const;
 
    std::string name_;
};
} // namespace pixelbullet::log
 
namespace pixelbullet
{
struct ApplicationBootstrap;
struct ApplicationSpecification;
} // namespace pixelbullet
 
namespace pixelbullet::logging
{
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_assets = "core.assets";
inline constexpr std::string_view core_shader = "core.shader";
 
inline constexpr std::string_view client = "client";
 
inline constexpr std::string_view vulkan_validation = "vulkan.validation";
} // namespace names
 
void Initialize(const ApplicationBootstrap& bootstrap, const log::LogConfig& config = {});
void Shutdown();
 
[[nodiscard]] bool IsInitialized();
[[nodiscard]] std::shared_ptr<log::Logger> Get(std::string_view name);
 
void UpdateSessionMetadata(const ApplicationSpecification& specification);
 
[[nodiscard]] std::filesystem::path GetLogRoot();
[[nodiscard]] std::filesystem::path GetSessionDirectory();
[[nodiscard]] std::filesystem::path GetLatestManifestPath();
} // namespace pixelbullet::logging
 
namespace pixelbullet::log
{
template <typename... Args>
void Trace(fmt::format_string<Args...> fmtStr, Args&&... args)
{
    logging::Get(logging::names::core)->Trace(fmtStr, std::forward<Args>(args)...);
}
 
template <typename... Args>
void Info(fmt::format_string<Args...> fmtStr, Args&&... args)
{
    logging::Get(logging::names::core)->Info(fmtStr, std::forward<Args>(args)...);
}
 
template <typename... Args>
void Warn(fmt::format_string<Args...> fmtStr, Args&&... args)
{
    logging::Get(logging::names::core)->Warn(fmtStr, std::forward<Args>(args)...);
}
 
template <typename... Args>
void Error(fmt::format_string<Args...> fmtStr, Args&&... args)
{
    logging::Get(logging::names::core)->Error(fmtStr, std::forward<Args>(args)...);
}
 
template <typename... Args>
void Critical(fmt::format_string<Args...> fmtStr, Args&&... args)
{
    logging::Get(logging::names::core)->Critical(fmtStr, std::forward<Args>(args)...);
}
} // namespace pixelbullet::log