NetDiagnostics.h

Go to the documentation of this file.

#ifndef BOMBERMAN_NET_NETDIAGNOSTICS_H
#define BOMBERMAN_NET_NETDIAGNOSTICS_H
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
 
#include <nlohmann/json.hpp>
 
#include "NetCommon.h"
#include "NetDiagConfig.h"
#include "NetDiagShared.h"
 
namespace bomberman::net
{
    struct ServerSessionConfig
    {
        uint16_t protocolVersion = 0;
        uint16_t tickRate = 0;
        uint32_t inputLeadTicks = 0;
        uint32_t snapshotIntervalTicks = 0;
        uint32_t brickSpawnRandomize = 0;
        uint32_t powerupsPerRound = 0;
        uint8_t maxPlayers = 0;
        bool powersEnabled = true;
    };
 
    struct ServerKeyMessageAggregates
    {
        uint64_t snapshotSent = 0;
        uint64_t correctionSent = 0;
        uint64_t inputRecv = 0;
        uint64_t gameplayEventSent = 0;
    };
 
    struct NetSessionSummary
    {
        bool enabled = true;
        bool active = false;
 
        uint64_t beginTimestampMs = 0;
        uint64_t endTimestampMs = 0;
        uint64_t durationMs = 0;
 
        uint64_t tickCount = 0;
 
        uint64_t recentEventsRecorded = 0;
        uint64_t recentEventsEvicted = 0;
 
        uint64_t packetsSent = 0;
        uint64_t packetsRecv = 0;
        uint64_t packetBytesSent = 0;
        uint64_t packetBytesRecv = 0;
        uint64_t packetsSentFailed = 0;
        uint64_t packetsRecvFailed = 0;
        uint64_t malformedPacketsRecv = 0;
 
        uint64_t inputPacketsReceived = 0;
        uint64_t inputPacketsFullyStale = 0;
        uint64_t inputEntriesTooLate = 0;
        uint64_t inputEntriesTooLateDirect = 0; 
        uint64_t inputEntriesTooLateBuffered = 0; 
        uint64_t inputEntriesTooFarAhead = 0;
 
        uint64_t directDeadlineConsumes = 0; 
        uint64_t simulationGaps = 0; 
        uint64_t bufferedDeadlineRecoveries = 0; 
        uint64_t bombsPlaced = 0;
        uint64_t bricksDestroyed = 0;
        uint64_t roundsEnded = 0;
        uint64_t roundsDrawn = 0;
        std::array<uint64_t, kMaxPlayers> roundWinsByPlayerId{}; 
    };
 
    class NetDiagnostics
    {
    public:
        // ----- Lifecycle -----
 
        NetDiagnostics(bool enabled = true);
 
        void beginSession(std::string_view ownerTag, bool enabled = true);
 
        void endSession();
 
        // ----- Recent-event extension seam -----
 
        void recordEvent(const NetEvent& event);
 
        // ----- Packet accounting -----
 
        void recordPacketSent(EMsgType type, uint8_t peerId, uint8_t channelId, std::size_t bytes, NetPacketResult result = NetPacketResult::Ok);
 
        void recordPacketRecv(EMsgType type, uint8_t peerId, uint8_t channelId, std::size_t bytes, NetPacketResult result = NetPacketResult::Ok);
 
        void recordMalformedPacketRecv(uint8_t peerId, uint8_t channelId, std::size_t bytes, std::string_view note = {});
 
        void recordPeerLifecycle(NetPeerLifecycleType type, uint8_t peerId, uint32_t transportPeerId, std::string_view note = {});
 
        // ----- Input stream and simulation continuity -----
 
        void recordInputPacketReceived();
 
        void recordInputPacketFullyStale(uint32_t count = 1);
 
        void recordInputEntriesTooLate(uint32_t count);
 
        void recordInputEntriesTooLateDirect(uint32_t count);
 
        void recordInputEntriesTooLateBuffered(uint32_t count);
 
        void recordInputEntriesTooFarAhead(uint32_t count);
 
        void recordSimulationGap(uint8_t peerId, uint32_t inputSeq, uint8_t heldButtons, uint32_t serverTick);
 
        void recordDirectDeadlineConsume(uint8_t peerId, uint32_t inputSeq);
 
        void recordBufferedDeadlineRecovery(uint8_t peerId, uint32_t inputSeq, uint32_t serverTick);
 
        void recordBombPlaced();
        void recordBricksDestroyed(uint32_t count);
        void recordRoundEnded(std::optional<uint8_t> winnerPlayerId, bool endedInDraw, uint32_t serverTick);
 
        // ----- Latest per-player-id state sampling -----
 
        void samplePeerTransport(uint8_t peerId, uint32_t rttMs, uint32_t rttVarianceMs, uint32_t packetLossPermille, uint32_t queuedReliable, uint32_t queuedUnreliable);
 
        void samplePeerInputContinuity(uint8_t peerId, uint32_t lastReceivedInputSeq, uint32_t lastProcessedInputSeq);
 
        void recordServerFlowState(std::string_view stateName, bool idle, uint32_t serverTick, uint32_t matchId = 0);
 
        // ----- Reporting -----
 
        void advanceTick();
 
        void recordSessionConfig(ServerSessionConfig config);
 
        [[nodiscard]]
        nlohmann::json toJson() const;
 
        bool writeJsonReport(std::string_view filePath) const;
 
    private:
        // ----- Internal helpers -----
 
        static uint64_t nowMs();
        static uint64_t recentEventDedupeCooldownMs(const NetEvent& event);
        static std::string makeRecentEventSignature(const NetEvent& event);
        static bool isAlwaysEmitEvent(const NetEvent& event);
 
        static bool shouldEmitPacketEvent(NetPacketResult result);
 
        void recordEvent(NetEventType type, std::string_view note = {});
 
        void resetForNewSession(std::string_view ownerTag, bool enabled);
 
        void recordRecentEvent(NetEvent event);
        void pushRecentEvent(NetEvent event);
 
        // ----- State -----
 
        bool enabled_ = true;
        bool sessionActive_ = false;
 
        std::string ownerTag_;
        ServerSessionConfig config_{};
        NetSessionSummary summary_{};
        ServerKeyMessageAggregates keyMessages_{};
        std::string serverFlowState_;
        bool serverIdle_ = false;
 
        std::array<NetEvent, kRecentEventCapacity> recentEvents_{};
        std::size_t recentStart_ = 0;
        std::size_t recentCount_ = 0;
 
        std::unordered_map<uint8_t, NetPeerTransportSample> latestPeerSamples_;
        std::unordered_map<uint8_t, NetPeerContinuitySummary> peerContinuitySummaries_;
        std::unordered_map<std::string, RecentEventRepeatState> recentEventRepeatState_;
    };
 
} // namespace bomberman::net
 
#endif // BOMBERMAN_NET_NETDIAGNOSTICS_H