RPCDoSDetection.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/CoreNet.h"
#include "Analytics/RPCDoSDetectionAnalytics.h"
 
#include "RPCDoSDetection.generated.h"
 
 
// Defines
 
#define RPC_QUOTA_DEBUG 0
 
#define RPC_DOS_DEV_STATS 0
 
#define RPC_DOS_SCOPE_DEBUG 1
 
 
// Typedefs
 
using FGetRPCDoSAddress = TUniqueFunction<FString()>;
 
using FGetRPCDoSPlayerUID = TUniqueFunction<FString()>;
 
using FRPCDoSKickPlayer = TUniqueFunction<void()>;
 
 
// Globals/CVars
 
#if RPC_DOS_SCOPE_DEBUG
namespace UE::Net
{
    extern int32 GRPCDoSScopeDebugging;
}
#endif
 
 
// Structs
 
struct FRPCDoSCounters
{
    int32 RPCCounter            = 0;
 
    double AccumRPCTime         = 0.0;
 
#if RPC_QUOTA_DEBUG
    double DebugAccumRPCTime    = 0.0;
#endif
 
 
public:
    void ResetRPCCounters()
    {
        RPCCounter = 0;
        AccumRPCTime = 0.0;
 
#if RPC_QUOTA_DEBUG
        DebugAccumRPCTime = 0.0;
#endif
    }
 
    void AccumulateCounter(const FRPCDoSCounters& InCounter)
    {
        RPCCounter += InCounter.RPCCounter;
        AccumRPCTime += InCounter.AccumRPCTime;
 
#if RPC_QUOTA_DEBUG
        DebugAccumRPCTime += InCounter.DebugAccumRPCTime;
#endif
    }
};
 
enum class ERPCBlockState : uint8
{
    Unchecked,      // The status for this RPC has not been checked
    OnAllowList,    // The RPC is allow listed and can't be blocked
    NotBlocked,     // The RPC is not blocked
    Blocked         // The RPC is blocked
};
 
struct FRPCTrackingInfo
{
    FRPCDoSCounters PerPeriodHistory[16]        = {};
 
    uint8 HistoryCount                          = 0;
 
    uint8 LastTrackedSecondIncrement            = 0;
 
    ERPCBlockState BlockState                   = ERPCBlockState::Unchecked;
 
    TSharedPtr<FRPCAnalytics> RPCTrackingAnalyticsEntry;
 
 
public:
    uint8 GetCurrentHistoryIdx() const
    {
        static_assert(UE_ARRAY_COUNT(PerPeriodHistory) == 16, "PerPeriodHistory must be 16 in size, for GetCurrentHistoryIdx to work.");
 
        return LastTrackedSecondIncrement & 0xF;
    }
};
 
struct FActiveRPCTrackingInfo
{
    void* Key                               = nullptr;
 
    const FRPCTrackingInfo* TrackingInfo    = nullptr;
};
 
 
USTRUCT()
struct FRPCDoSState
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(config)
    bool bLogEscalate               = false;
 
    UPROPERTY(config)
    bool bSendEscalateAnalytics     = false;
 
    UPROPERTY(config)
    bool bKickPlayer                = false;
 
    UPROPERTY(config)
    bool bTrackRecentRPCs           = false;
 
 
    UPROPERTY(config)
    int16 EscalateQuotaRPCsPerFrame     = -1;
 
    UPROPERTY(config)
    int16 EscalateTimeQuotaMSPerFrame   = -1;
 
    UPROPERTY(config)
    int16 EscalateQuotaRPCsPerPeriod    = -1;
 
    UPROPERTY(config)
    int16 EscalateTimeQuotaMSPerPeriod  = -1;
 
    UPROPERTY(config)
    int8 EscalateQuotaTimePeriod        = -1;
 
 
    UPROPERTY(config)
    int8 EscalationCountTolerance       = 1;
 
    UPROPERTY(config)
    int16 EscalationTimeToleranceMS     = -1;
 
 
    UPROPERTY(config)
    int16 RPCRepeatLimitPerPeriod       = -1;
 
    UPROPERTY(config)
    int16 RPCRepeatLimitMSPerPeriod     = -1;
 
    UPROPERTY(config)
    int8 RPCRepeatLimitTimePeriod       = -1;
 
 
    UPROPERTY(config)
    int16 CooloffTime                   = -1;
 
    UPROPERTY(config)
    int16 AutoEscalateTime              = -1;
 
 
    double EscalateTimeQuotaSecsPerFrame    = 0.0;
 
    double EscalateTimeQuotaSecsPerPeriod   = 0.0;
 
    double RPCRepeatLimitSecsPerPeriod      = 0.0;
 
    double EscalationTimeToleranceSeconds   = 0.0;
 
 
public:
    virtual ~FRPCDoSState()
    {
    }
 
    ENGINE_API virtual void ApplyImpliedValues();
 
    bool HasHitQuota_Count(const FRPCDoSCounters(&PerPeriodHistory)[16], FRPCDoSCounters& InFrameCounter) const;
 
    bool HasHitQuota_Time(const FRPCDoSCounters(&PerPeriodHistory)[16], FRPCDoSCounters& InFrameCounter) const;
};
 
USTRUCT()
struct FRPCDoSStateConfig : public FRPCDoSState
{
    GENERATED_USTRUCT_BODY()
 
    
    FString SeverityCategory;
 
 
private:
    int8 HighestTimePeriod = 0;
 
    TArray<int8> AllTimePeriods;
 
 
public:
    bool bEscalationConfirmed = false;
 
    int16 EscalationCount = 0;
 
 
public:
    ENGINE_API virtual void ApplyImpliedValues() override;
 
    bool LoadStructConfig(const TCHAR* SectionName, const TCHAR* InFilename=nullptr);
 
    void ValidateConfig();
 
    int8 GetHighestTimePeriod() const;
 
    const TArray<int8>& GetAllTimePeriods() const;
 
    void ApplyState(FRPCDoSState& Target);
};
 
 
 
enum class ERPCNotifyResult : uint8
{
    ExecuteRPC,     // Allow the RPC to execute
    BlockRPC        // Block the RPC from executing
};
 
enum class ERPCDoSSeverityUpdate : uint8
{
    Escalate,       // Escalating to a higher RPC DoS escalation state
    AutoEscalate,   // Automatic/non-RPC escalation to a higher RPC DoS escalation state, e.g. when too much time was spent in a lower state
    Deescalate      // Deescalating to a lower RPC DoS escalation state
};
 
enum class ERPCDoSEscalateReason : uint8
{
    CountLimit,     // RPC Count quota's were hit
    TimeLimit,      // RPC Time quota's were hit
    AutoEscalate,   // Automatic escalation from a lower state, e.g. after spending too much time in a lower state
    Deescalate      // Deescalation to a lower state
};
 
enum class EPostSequentialRPCType : uint8
{
    MidPacket,      // End of RPC sequence while still processing packet
    PostPacket      // End of RPC sequence after a packet has finished processing
};
 
 
 
class FRPCDoSDetection : protected FRPCDoSState
{
    friend struct FRPCDoSStateConfig;
 
    struct FLightweightRPCTracking
    {
        static constexpr int32 TrackingNum = 256;
 
        struct FLightweightRPCEntry
        {
            UFunction* Function;
 
            FName Name;
        };
 
 
        FLightweightRPCEntry RPC[TrackingNum] = {};
 
        uint8 Count = 0;
    };
 
public:
    void Init(FName NetDriverName, TSharedPtr<FNetAnalyticsAggregator>& AnalyticsAggregator, FGetWorld&& InWorldFunc,
                FGetRPCDoSAddress&& InAddressFunc, FGetRPCDoSPlayerUID&& InPlayerUIDFunc, FRPCDoSKickPlayer&& InKickPlayerFunc);
 
    void InitConfig(FName NetDriverName);
 
    UE_DEPRECATED(5.1, "UpdateSeverity will be made private soon.")
    void UpdateSeverity(ERPCDoSSeverityUpdate Update, ERPCDoSEscalateReason Reason)
    {
        UpdateSeverity_Private(Update, Reason);
    }
 
 
    void PreTickDispatch(double TimeSeconds);
 
    void PreReceivedPacket(double TimeSeconds)
    {
        using namespace UE::Net;
 
#if RPC_DOS_DEV_STATS
        CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RPCDoS_Checks);
#endif
 
#if RPC_DOS_SCOPE_DEBUG
        ensure(GRPCDoSScopeDebugging == 0 || TickScopePrivate.IsActive());
        ensure(GRPCDoSScopeDebugging == 0 || !SequentialRPCScopePrivate.IsActive());
#endif
 
        PacketScopePrivate.SetActive(true);
 
        FPacketScope& PacketScope = GetPacketScope();
 
        PacketScope.ReceivedPacketStartTime = TimeSeconds;
 
        // Redundant call to Reset for sequential RPC scope - remove when scope debugging verifies the sequential RPC scope is never active here
#if 1 // !RPC_DOS_SCOPE_DEBUG
        SequentialRPCScopePrivate.Reset();
#endif
    }
 
    ERPCNotifyResult NotifyReceivedRPC(FNetBitReader& Reader, TSet<FNetworkGUID>& UnmappedGuids, UObject* Object, UFunction* Function,
                                        FName FunctionName)
    {
        ERPCNotifyResult Result = ERPCNotifyResult::ExecuteRPC;
 
#if RPC_DOS_DEV_STATS
        CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RPCDoS_Checks);
#endif
 
        if (bRPCDoSDetection && !bHitchSuspendDetection)
        {
            if (!SequentialRPCScopePrivate.IsActive())
            {
                PreSequentialRPC();
            }
 
            if (bRPCTrackingEnabled)
            {
                FSequentialRPCScope& SequentialRPCScope = GetSequentialRPCScope();
 
                Result = SequentialRPCScope.CheckRPCTracking(*this, Function, FunctionName);
            }
 
#if RPC_QUOTA_DEBUG
            FSequentialRPCScope& SequentialRPCScope = GetSequentialRPCScope();
 
            SequentialRPCScope.DebugReceivedRPCStartTime = FPlatformTime::Seconds();
#endif
        }
 
 
        return Result;
    }
 
    void LightweightReceivedRPC(UFunction* Function, FName FunctionName)
    {
#if RPC_DOS_DEV_STATS
        CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RPCDoS_Checks);
#endif
 
        if (bRPCDoSDetection && !bHitchSuspendDetection)
        {
            if (!SequentialRPCScopePrivate.IsActive())
            {
                PreSequentialRPC();
            }
 
            if (UNLIKELY(ForcedRPCTracking == FunctionName && FMath::FRand() <= ForcedRPCTrackingChance))
            {
                EnableForcedRPCTracking(Function, FunctionName, FPlatformTime::Seconds());
            }
            else
            {
                FSequentialRPCScope& SequentialRPCScope = GetSequentialRPCScope();
                FLightweightRPCTracking& LightweightRPCTracking = SequentialRPCScope.LightweightRPCTracking;
                FLightweightRPCTracking::FLightweightRPCEntry& CurEntry = LightweightRPCTracking.RPC[LightweightRPCTracking.Count++];
 
                CurEntry.Function = Function;
                CurEntry.Name = FunctionName;
            }
        }
    }
 
    void PostReceivedRPC()
    {
#if RPC_DOS_DEV_STATS
        CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RPCDoS_Checks);
#endif
 
#if RPC_QUOTA_DEBUG
        {
            FPacketScope& PacketScope = GetPacketScope();
 
            PacketScope.DebugReceivedRPCEndTime = FPlatformTime::Seconds();
            FrameCounter.DebugAccumRPCTime += (PacketScope.DebugReceivedRPCEndTime - PacketScope.DebugReceivedRPCStartTime);
        }
#endif
 
        if (bRPCDoSDetection && !bHitchSuspendDetection)
        {
            FTickScope& TickScope = GetTickScope();
            FPacketScope& PacketScope = GetPacketScope();
            FSequentialRPCScope& SequentialRPCScope = GetSequentialRPCScope();
 
            TickScope.FrameCounter.RPCCounter++;
 
            RPCIntervalCounter++;
            SequentialRPCScope.ReceivedPacketRPCCount++;
            PacketScope.bPacketContainsRPC = true;
 
            TickScope.CondCheckCountQuota(*this);
        }
    }
 
    void PostSequentialRPC(EPostSequentialRPCType SequenceType, double TimeSeconds, FRPCDoSCounters* RPCCounter,
                            FRPCTrackingInfo* RPCTrackingInfo);
 
    void PostReceivedPacket(double TimeSeconds)
    {
        using namespace UE::Net;
 
#if RPC_DOS_DEV_STATS
        CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RPCDoS_Checks);
#endif
 
        if (GetPacketScope().bPacketContainsRPC)
        {
            PostReceivedRPCPacket(TimeSeconds);
        }
 
        ReceivedPacketEndTime = TimeSeconds;
 
        PacketScopePrivate.SetActive(false);
 
#if RPC_DOS_SCOPE_DEBUG
        ensure(GRPCDoSScopeDebugging == 0 || !SequentialRPCScopePrivate.IsActive());
        ensure(GRPCDoSScopeDebugging == 0 || TickScopePrivate.IsActive());
#endif
    }
 
    void PostReceivedRPCPacket(double TimeSeconds);
 
    void PostTickDispatch();
 
    void NotifyClose();
 
 
    bool ShouldMonitorReceivedRPC() const
    {
#if RPC_QUOTA_DEBUG
        return true;
#endif
 
        return bRPCTrackingEnabled;
    }
 
    bool IsRPCDoSDetectionEnabled() const
    {
        return bRPCDoSDetection;
    }
 
    void SetAddressFunc(FGetRPCDoSAddress&& InAddressFunc);
 
    void SetPlayerUIDFunc(FGetRPCDoSPlayerUID&& InPlayerUIDFunc);
 
    void SetKickPlayerFunc(FRPCDoSKickPlayer&& InKickPlayerFunc);
 
 
private:
    void PreSequentialRPC()
    {
        using namespace UE::Net;
 
#if RPC_DOS_SCOPE_DEBUG
        ensure(GRPCDoSScopeDebugging == 0 || TickScopePrivate.IsActive());
        ensure(GRPCDoSScopeDebugging == 0 || PacketScopePrivate.IsActive());
#endif
 
        SequentialRPCScopePrivate.SetActive(true);
    }
 
    void UpdateSeverity_Private(ERPCDoSSeverityUpdate Update, ERPCDoSEscalateReason Reason);
 
    void InitState(double TimeSeconds);
 
    void CondCheckCountQuota()
    {
        // 64 RPC interval
        if ((RPCIntervalCounter & 0x3F) == 0)
        {
            FTickScope& TickScope = GetTickScope();
 
            if (HasHitQuota_Count(CounterPerPeriodHistory, TickScope.FrameCounter))
            {
                TickScope.UpdateSeverity(*this, ERPCDoSSeverityUpdate::Escalate, ERPCDoSEscalateReason::CountLimit);
            }
        }
    }
 
    void CondCheckTimeQuota(double TimeSeconds)
    {
        if (TimeSeconds > NextTimeQuotaCheck)
        {
            FTickScope& TickScope = GetTickScope();
 
            NextTimeQuotaCheck = TimeSeconds + TimeQuotaCheckInterval;
 
            if (HasHitQuota_Time(CounterPerPeriodHistory, TickScope.FrameCounter))
            {
                TickScope.UpdateSeverity(*this, ERPCDoSSeverityUpdate::Escalate, ERPCDoSEscalateReason::TimeLimit);
            }
        }
    }
 
    ERPCNotifyResult CheckRPCTracking(UFunction* Function, FName FunctionName);
 
    void RecalculatePeriodHistory(const TArray<int8>& InTimePeriods, FRPCDoSCounters(&OutPerPeriodHistory)[16],
                                    int32 StartPerSecHistoryIdx=INDEX_NONE);
 
 
    void EnableRPCTracking(double TimeSeconds);
 
    void EnableForcedRPCTracking(UFunction* Function, FName FunctionName, double TimeSeconds);
 
    void DisableRPCTracking(double TimeSeconds);
 
    FRPCTrackingInfo& FindOrAddRPCTracking(UFunction* InFunc, bool& bOutNewTracking)
    {
        TSharedPtr<FRPCTrackingInfo>& SharedResult = RPCTracking.FindOrAdd(InFunc);
 
        if (!SharedResult.IsValid())
        {
            SharedResult = MakeShared<FRPCTrackingInfo>();
 
            ActiveRPCTracking.Add({InFunc, SharedResult.Get()});
 
            bOutNewTracking = true;
        }
 
        return *SharedResult.Get();
    }
 
    void ClearStaleRPCTracking(double TimeSeconds);
 
 
    void CachePlayerAddress();
 
    void CachePlayerUID();
 
    const FString& GetPlayerAddress()
    {
        return CachedAddress;
    }
 
    const FString& GetPlayerUID()
    {
        return CachedPlayerUID;
    }
 
 
private:
    template<class T>
    class TScopeBase
    {
    public:
        inline void SetActive(bool bInVal)
        {
            using namespace UE::Net;
 
#if RPC_DOS_SCOPE_DEBUG
            ensure(GRPCDoSScopeDebugging == 0 || bScopeActive != bInVal);
#endif
 
            bScopeActive = bInVal;
 
            Reset();
        }
 
        inline bool IsActive() const
        {
            return bScopeActive;
        }
 
        inline void Reset()
        {
            static_cast<T*>(this)->Reset();
        }
 
    private:
        bool bScopeActive = false;
    };
 
    class FTickScope : public TScopeBase<FTickScope>
    {
    public:
        inline void UpdateSeverity(FRPCDoSDetection& This, ERPCDoSSeverityUpdate Update, ERPCDoSEscalateReason Reason)
        {
            This.UpdateSeverity_Private(Update, Reason);
        }
 
        inline void CondCheckCountQuota(FRPCDoSDetection& This)
        {
            This.CondCheckCountQuota();
        }
 
        inline void CondCheckTimeQuota(FRPCDoSDetection& This, double TimeSeconds)
        {
            This.CondCheckTimeQuota(TimeSeconds);
        }
 
        void Reset()
        {
            FrameCounter.ResetRPCCounters();
        }
 
    public:
        FRPCDoSCounters FrameCounter;
    };
 
    FTickScope TickScopePrivate;
 
 
    inline FTickScope& GetTickScope()
    {
        using namespace UE::Net;
 
#if RPC_DOS_SCOPE_DEBUG
        ensure(GRPCDoSScopeDebugging == 0 || TickScopePrivate.IsActive());
#endif
 
        return TickScopePrivate;
    }
 
 
    class FPacketScope : public TScopeBase<FPacketScope>
    {
    public:
        bool bPacketContainsRPC                                         = false;
 
        double ReceivedPacketStartTime                                  = 0.0;
 
 
    public:
        void Reset()
        {
            bPacketContainsRPC = false;
            ReceivedPacketStartTime = 0.0;
        }
    };
 
    FPacketScope PacketScopePrivate;
 
 
    inline FPacketScope& GetPacketScope()
    {
        using namespace UE::Net;
 
#if RPC_DOS_SCOPE_DEBUG
        ensure(GRPCDoSScopeDebugging == 0 || PacketScopePrivate.IsActive());
#endif
 
        return PacketScopePrivate;
    }
 
    class FSequentialRPCScope : public TScopeBase<FSequentialRPCScope>
    {
    public:
        inline void CondCheckCountQuota(FRPCDoSDetection& This)
        {
            This.CondCheckCountQuota();
        }
 
        inline void CondCheckTimeQuota(FRPCDoSDetection& This, double TimeSeconds)
        {
            This.CondCheckTimeQuota(TimeSeconds);
        }
 
        inline ERPCNotifyResult CheckRPCTracking(FRPCDoSDetection& This, UFunction* Function, FName FunctionName)
        {
            return This.CheckRPCTracking(Function, FunctionName);
        }
 
        inline FRPCTrackingInfo& FindOrAddRPCTracking(FRPCDoSDetection& This, UFunction* InFunc, bool& bOutNewTracking)
        {
            return This.FindOrAddRPCTracking(InFunc, bOutNewTracking);
        }
 
        void Reset()
        {
            bReceivedPacketRPCUnique = true;
            ReceivedPacketRPCCount = 0;
            LightweightRPCTracking.Count = 0;
            PostReceivedRPCName = NAME_None;
            PostReceivedRPCTracking = nullptr;
            PostReceivedRPCCounter = nullptr;
            PostReceivedRPCBlockCount = 0;
            LastReceivedRPCTimeCache = 0.0;
 
#if RPC_QUOTA_DEBUG
            DebugReceivedRPCStartTime = 0.0;
            DebugReceivedRPCEndTime = 0.0;
#endif
        }
 
    public:
        bool bReceivedPacketRPCUnique                                   = true;
 
        int32 ReceivedPacketRPCCount                                    = 0;
 
        FLightweightRPCTracking LightweightRPCTracking;
 
 
        FName PostReceivedRPCName;
 
        FRPCTrackingInfo* PostReceivedRPCTracking                       = nullptr;
 
        FRPCDoSCounters* PostReceivedRPCCounter                         = nullptr;
 
        int32 PostReceivedRPCBlockCount                                 = 0;
 
        double LastReceivedRPCTimeCache                                 = 0.0;
 
#if RPC_QUOTA_DEBUG
        double DebugReceivedRPCStartTime                                = 0.0;
 
        double DebugReceivedRPCEndTime                                  = 0.0;
#endif
    };
 
    FSequentialRPCScope SequentialRPCScopePrivate;
 
    inline FSequentialRPCScope& GetSequentialRPCScope()
    {
        using namespace UE::Net;
 
#if RPC_DOS_SCOPE_DEBUG
        ensure(GRPCDoSScopeDebugging == 0 || SequentialRPCScopePrivate.IsActive());
#endif
 
        return SequentialRPCScopePrivate;
    }
 
 
private:
    bool bRPCDoSDetection                                           = false;
 
    bool bRPCDoSAnalytics                                           = false;
 
    int32 HitchTimeQuotaMS                                          = 0;
 
    int32 HitchSuspendDetectionTimeMS                               = 0;
 
    TArray<FName> RPCBlockAllowList;
 
    FName ForcedRPCTracking;
 
    double ForcedRPCTrackingChance                                  = 1.0;
 
    double ForcedRPCTrackingLength                                  = 0.0;
 
    double ForcedRPCTrackingEndTime                                 = 0.0;
 
 
    FGetRPCDoSAddress AddressFunc;
 
    FString CachedAddress;
 
    FGetRPCDoSPlayerUID PlayerUIDFunc;
 
    FString CachedPlayerUID;
 
    FRPCDoSKickPlayer KickPlayerFunc;
 
 
    TArray<FRPCDoSStateConfig> DetectionSeverity;
 
    int8 ActiveState                                                = 0;
 
    int8 WorstActiveState                                           = 0;
 
    int8 WorstAnalyticsState                                        = 0;
 
    double LastMetEscalationConditions                              = 0.0;
 
    bool bHitchSuspendDetection                                     = false;
 
    double HitchSuspendDetectionStartTime                           = 0.0;
 
 
    FRPCDoSCounters SecondCounter;
 
    double LastPerSecQuotaBegin                                     = 0.0;
 
    TArray<FRPCDoSCounters> CounterPerSecHistory;
 
    int32 LastCounterPerSecHistoryIdx                               = 0;
 
    FRPCDoSCounters CounterPerPeriodHistory[16]                     = {};
 
    uint8 SecondsIncrementer                                        = 0;
 
 
    double ReceivedPacketEndTime                                    = 0.0;
 
    double LastPreTickDispatchTime                                  = 0.0;
 
    uint32 RPCIntervalCounter                                       = 0;
 
    double NextTimeQuotaCheck                                       = 0.0;
 
    static constexpr double TimeQuotaCheckInterval                  = 0.005;
 
 
    bool bRPCTrackingEnabled                                        = false;
 
    int8 MaxRPCTrackingPeriod                                       = 0;
 
    TMap<void*, TSharedPtr<FRPCTrackingInfo>> RPCTracking;
 
    TArray<FActiveRPCTrackingInfo> ActiveRPCTracking;
 
    static constexpr int32 DefaultActiveRPCTrackingSize             = 128;
 
    double LastRPCTrackingClean                                     = 0.0;
 
 
    FRPCDoSAnalyticsVars AnalyticsVars;
 
    TNetAnalyticsDataPtr<FRPCDoSAnalyticsData> RPCDoSAnalyticsData;
 
    double AnalyticsMinTimePerSecThreshold                          = 0.0;
 
    double LastAnalyticsThresholdRecalc                             = 0.0;
};