NetworkMetricsDatabase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "NetworkMetricsDatabase.generated.h"
 
#define UE_API ENGINE_API
 
struct FNetworkMetricsMutator;
 
template<typename BaseStructT>
struct [[nodiscard]] TInstancedStruct;
 
namespace UE::Net
{
 
template<class MetricType>
struct FNetworkMetric
{
    FName Name;
    MetricType Value;
};
 
struct FNetworkMetricSnapshot
{
    TArray<FNetworkMetric<int64>> MetricInts;
    TArray<FNetworkMetric<float>> MetricFloats;
 
    void Reset()
    {
        MetricInts.Reset();
        MetricFloats.Reset();
    }
};
 
} // namespace UE::Net
 
UCLASS(MinimalAPI)
class UNetworkMetricsDatabase : public UObject
{
    GENERATED_BODY()
 
public:
    /* Add a floating point metric. */
    UE_API void CreateFloat(const FName MetricName, float DefaultValue);
    /* Add an integer metric. */
    UE_API void CreateInt(const FName MetricName, int64 DefaultValue);
    /* Set the value of an existing floating point metric. */
    UE_API bool SetFloat(const FName MetricName, float Value);
    /* Set the value of a floating point metric if it's smaller than the existing value. */
    UE_API bool SetMinFloat(const FName MetricName, float Value);
    /* Set the value of a floating point metric if it's bigger than the existing value. */
    UE_API bool SetMaxFloat(const FName MetricName, float Value);
    UE_API float GetFloat(const FName MetricName);
    /* Set the value of an existing integer metric. */
    UE_API bool SetInt(const FName MetricName, int64 Value);
    /* Set the value of an integer metric if it's smaller than the existing value. */
    UE_API bool SetMinInt(const FName MetricName, int64 Value);
    /* Set the value of an integer metric if it's bigger than the existing value. */
    UE_API bool SetMaxInt(const FName MetricName, int64 Value);
    /* Increment the value of an existing integer metric. */
    UE_API bool IncrementInt(const FName MetricName, int64 Value);
    UE_API int64 GetInt(const FName MetricName);
    /* Returns true if a metric has been created in the database. */
    UE_API bool Contains(const FName MetricName) const;
 
    /* Call all registered listeners.*/
    UE_API void ProcessListeners();
    /* Remove all registered metrics and listeners. */
    UE_API void Reset();
    /* Remove all registered listeners. */
    UE_API void ResetListeners();
 
    /* Register a listener to be called for a given metric. */
    UE_API void Register(const FName MetricName, TWeakObjectPtr<UNetworkMetricsBaseListener> Reporter);
 
    /* Register a mutator with a listener. */
    UE_API void RegisterMutator(TWeakObjectPtr<UNetworkMetricsBaseListener> Listener, const TInstancedStruct<FNetworkMetricsMutator>& Mutator);
 
private:
    /* Return true if the report interval time for a listener has elapsed, and update its last reported time if it has. */
    bool HasReportIntervalPassed(double CurrentTimeSeconds, UNetworkMetricsBaseListener* Listener);
 
    enum class EMetricType { Integer, Float };
 
    void AddMetricToSnapshot(UE::Net::FNetworkMetricSnapshot& Snapshot, const FName MetricName, const EMetricType MetricType);
 
    TMap<FName, EMetricType> MetricTypes;
 
    TMap<FName, UE::Net::FNetworkMetric<int64>> MetricInts;
    TMap<FName, UE::Net::FNetworkMetric<float>> MetricFloats;
 
    using FNameAndType = TPair<FName, EMetricType>;
 
    /* The time, in seconds, metrics were reported to a listener. */
    TMap<TWeakObjectPtr<UNetworkMetricsBaseListener>, double> LastReportListener;
 
    // Map of listeners to metrics registered with them. A listener may have an entry with an empty set if it has no metrics but some mutators registered. */
    TMap<TWeakObjectPtr<UNetworkMetricsBaseListener>, TSet<FNameAndType>> ListenersToMetrics;
};
 
UCLASS(MinimalAPI, abstract, Config=Engine)
class UNetworkMetricsBaseListener : public UObject
{
    GENERATED_BODY()
 
public:
    UE_API UNetworkMetricsBaseListener();
    virtual ~UNetworkMetricsBaseListener();
 
    /* Set the interval, in seconds, between calling Report(). */
    void SetInterval(double Seconds)
    {
        if (ensureMsgf(Seconds >= 0, TEXT("SetInterval() called with a negative time interval.")))
        {
            IntervalSeconds = Seconds;
        }
    }
 
    /* Get the interval, in seconds, between calling Report(). */
    double GetInterval() const
    {
        return IntervalSeconds;
    }
 
    const TArray<TInstancedStruct<FNetworkMetricsMutator>>& GetMutators() const
    {
        return Mutators;
    }
 
    TArray<TInstancedStruct<FNetworkMetricsMutator>>& GetMutators()
    {
        return Mutators;
    }
 
    virtual void Report(const UE::Net::FNetworkMetricSnapshot& Snapshot) {};
 
private:
    UPROPERTY(Config)
    double IntervalSeconds;
 
    UPROPERTY()
    TArray<TInstancedStruct<FNetworkMetricsMutator>> Mutators;
};
 
UCLASS(MinimalAPI)
class UNetworkMetricsLog : public UNetworkMetricsBaseListener
{
    GENERATED_BODY()
 
public:
    virtual ~UNetworkMetricsLog() = default;
 
    UE_API virtual void Report(const UE::Net::FNetworkMetricSnapshot& Snapshot);
};
 
UCLASS(MinimalAPI)
class UNetworkMetricsCSV : public UNetworkMetricsBaseListener
{
    GENERATED_BODY()
 
public:
    UE_API UNetworkMetricsCSV();
    virtual ~UNetworkMetricsCSV() = default;
 
    /* Set the CSV category. */
    UE_API void SetCategory(const FString& CategoryName);
 
    UE_API virtual void Report(const UE::Net::FNetworkMetricSnapshot& Snapshot);
 
private:
    int32 CategoryIndex;
};
 
UCLASS(MinimalAPI)
class UNetworkMetricsCSV_Replication : public UNetworkMetricsCSV
{
    GENERATED_BODY()
 
public:
    UNetworkMetricsCSV_Replication()
    {
        SetCategory("Replication");
    }
 
    virtual ~UNetworkMetricsCSV_Replication() = default;
};
 
UCLASS(MinimalAPI)
class UNetworkMetricsPerfCounters : public UNetworkMetricsBaseListener
{
    GENERATED_BODY()
 
public:
    virtual ~UNetworkMetricsPerfCounters() = default;
 
    UE_API virtual void Report(const UE::Net::FNetworkMetricSnapshot& Snapshot);
};
 
UCLASS(MinimalAPI)
class UNetworkMetricsStats : public UNetworkMetricsBaseListener
{
    GENERATED_BODY()
 
public:
    UE_API UNetworkMetricsStats();
    virtual ~UNetworkMetricsStats() = default;
 
    void SetStatName(const FName Name)
    {
        StatName = Name;
    }
 
    UE_API virtual void Report(const UE::Net::FNetworkMetricSnapshot& Snapshot);
 
private:
    FName StatName;
};
 
#undef UE_API