log_internal.h

#pragma once
 
#include "pixelbullet/logging/log.h"
#include "pixelbullet/logging/log_paths.h"
 
#include <chrono>
#include <filesystem>
#include <fstream>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <unordered_map>
 
namespace pixelbullet::logging_internal
{
using SystemClock = std::chrono::system_clock;
using SteadyClock = std::chrono::steady_clock;
 
class ConsoleSink
{
public:
    void write(const log::LogRecord& record);
 
private:
    std::mutex mutex_;
};
 
class TextFileSink
{
public:
    explicit TextFileSink(const std::filesystem::path& path);
 
    void write(const log::LogRecord& record);
 
private:
    std::mutex mutex_;
    std::ofstream stream_;
    std::filesystem::path path_;
    bool failed_ = false;
};
 
class NdjsonSink
{
public:
    explicit NdjsonSink(const std::filesystem::path& path);
 
    void write(const log::LogRecord& record);
 
private:
    std::mutex mutex_;
    std::ofstream stream_;
    std::filesystem::path path_;
    bool failed_ = false;
};
 
struct SessionMetadata
{
    std::string started_at;
    std::string ended_at;
    uint32_t process_id = 0;
    bool used_environment_override = false;
    std::string binary_stem;
    std::filesystem::path binary_path;
    std::filesystem::path current_working_directory;
    std::filesystem::path log_root;
    std::filesystem::path session_directory;
    std::filesystem::path latest_manifest_path;
    std::filesystem::path session_log_path;
    std::filesystem::path core_log_path;
    std::filesystem::path client_log_path;
    std::filesystem::path validation_log_path;
    std::filesystem::path events_ndjson_path;
    std::string client_name;
    std::string client_version;
    std::string engine_name;
    std::string engine_version;
};
 
struct LoggingState
{
    std::mutex mutex;
    bool initialized = false;
    log::LogConfig config;
    logging::detail::ResolvedLogPaths paths;
    SessionMetadata metadata;
    SteadyClock::time_point start_steady = SteadyClock::now();
    std::shared_ptr<ConsoleSink> console;
    std::shared_ptr<TextFileSink> session_sink;
    std::shared_ptr<TextFileSink> core_sink;
    std::shared_ptr<TextFileSink> client_sink;
    std::shared_ptr<TextFileSink> validation_sink;
    std::shared_ptr<NdjsonSink> ndjson;
    std::unordered_map<std::string, std::shared_ptr<log::Logger>> loggers;
};
 
struct MetadataSnapshot
{
    SessionMetadata metadata;
    std::filesystem::path session_metadata_path;
    std::filesystem::path latest_manifest_path;
};
 
enum class LatestManifestWrite
{
    Always,
    IfCurrent,
};
 
[[nodiscard]] LoggingState& GetState();
[[nodiscard]] std::shared_ptr<log::Logger> GetOrCreateLogger(LoggingState& state, std::string_view name);
[[nodiscard]] MetadataSnapshot MakeMetadataSnapshot(const LoggingState& state);
 
[[nodiscard]] std::string EscapeJson(std::string_view value);
[[nodiscard]] std::string JsonString(std::string_view value);
[[nodiscard]] std::string JsonPath(const std::filesystem::path& path);
[[nodiscard]] std::string JsonOptionalString(const std::string& value);
[[nodiscard]] std::string FormatIso8601(SystemClock::time_point time_point);
[[nodiscard]] std::string FormatElapsed(SteadyClock::duration duration);
[[nodiscard]] std::string ThreadIdToString();
[[nodiscard]] bool logger_matches_namespace(std::string_view value, std::string_view logger_namespace);
[[nodiscard]] std::string FormatTextRecord(const log::LogRecord& record);
[[nodiscard]] std::string FormatNdjsonRecord(const log::LogRecord& record);
 
void PersistMetadata(const MetadataSnapshot& snapshot, LatestManifestWrite latest_manifest_write);
[[nodiscard]] bool EnsureDirectoryExists(const std::filesystem::path& path);
[[nodiscard]] log::LogRecord BuildRecord(const LoggingState& state, std::string_view logger_name, log::Level level, std::string message);
 
void EmitRecord(const log::LogRecord& record, const std::shared_ptr<ConsoleSink>& console_sink,
                const std::shared_ptr<TextFileSink>& session_sink, const std::shared_ptr<TextFileSink>& core_sink,
                const std::shared_ptr<TextFileSink>& client_sink, const std::shared_ptr<TextFileSink>& validation_sink,
                const std::shared_ptr<NdjsonSink>& ndjson);
} // namespace pixelbullet::logging_internal