NetAnalytics.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
// Includes
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/Platform.h"
#include "Templates/Atomic.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/NameTypes.h"
 
// Forward Declarations
class FNetAnalyticsAggregator;
class IAnalyticsProvider;
struct FAnalyticsEventAttribute;
 
 
// Defines
 
#define NET_ANALYTICS_MULTITHREADING 0
 
 
inline constexpr const ESPMode NetAnalyticsThreadSafety = ESPMode::ThreadSafe;
 
 
// Forward Declarations
struct FNetAnalyticsData;
 
 
// Typedefs
template<class T=FNetAnalyticsData> using TNetAnalyticsDataRef = TSharedRef<T, NetAnalyticsThreadSafety>;
template<class T=FNetAnalyticsData> using TNetAnalyticsDataPtr = TSharedPtr<T, NetAnalyticsThreadSafety>;
template<class T=FNetAnalyticsData> using TNetAnalyticsDataWeakPtr = TWeakPtr<T, NetAnalyticsThreadSafety>;
 
 
// Defines
 
#define REGISTER_NET_ANALYTICS(Aggregator, AnalyticsDataType, InDataName) \
    StaticCastSharedPtr<AnalyticsDataType, FNetAnalyticsData, NetAnalyticsThreadSafety>( \
        (Aggregator->RegisterAnalyticsData_Internal(MakeShareable(new AnalyticsDataType(), FNetAnalyticsDataDeleter()), InDataName, \
            TEXT(#AnalyticsDataType))))
 
 
// Globals
 
extern NETCORE_API TAtomic<uint8> GNetAnalyticsCounter;
 
 
struct FLocalNetAnalyticsStruct : public FVirtualDestructor
{
};
 
 
struct FNetAnalyticsData : public FVirtualDestructor, public TSharedFromThis<FNetAnalyticsData, NetAnalyticsThreadSafety>
{
    friend class FNetAnalyticsAggregator;
    friend struct FNetAnalyticsDataDeleter;
 
protected:
    FNetAnalyticsAggregator* Aggregator;
 
 
public:
    NETCORE_API FNetAnalyticsData();
    NETCORE_API virtual ~FNetAnalyticsData();
 
    virtual void SendAnalytics() = 0;
 
 
protected:
    NETCORE_API virtual void InternalSendAnalytics();
 
    virtual void NotifyFinalRelease()
    {
    }
};
 
template<class TDataStruct> struct TBasicNetAnalyticsData : public FNetAnalyticsData, protected TDataStruct
{
    GENERATE_MEMBER_FUNCTION_CHECK(CommitAnalytics, void,, TDataStruct&);
 
    static_assert(THasMemberFunction_CommitAnalytics<TDataStruct>::Value, "TDataStruct must implement void CommitAnalytics(TDataStruct&)");
 
    void CommitAnalytics(TDataStruct& AnalyticsVars)
    {
        AnalyticsVars.CommitAnalytics(*this);
    }
};
 
#if NET_ANALYTICS_MULTITHREADING
struct FThreadedNetAnalyticsData : public FNetAnalyticsData
{
    NETCORE_API FThreadedNetAnalyticsData();
 
 
protected:
    NETCORE_API virtual void InternalSendAnalytics() override;
 
    NETCORE_API virtual void NotifyFinalRelease() override;
 
 
protected:
    TAtomic<bool> bReadyToSend;
};
 
template<class TDataStruct> struct TThreadedNetAnalyticsData : public FThreadedNetAnalyticsData, protected TDataStruct
{
    GENERATE_MEMBER_FUNCTION_CHECK(CommitAnalytics, void,, TDataStruct&);
 
    static_assert(THasMemberFunction_CommitAnalytics<TDataStruct>::Value, "TDataStruct must implement void CommitAnalytics(TDataStruct&)");
    static_assert(TIsDerivedFrom<TDataStruct, FLocalNetAnalyticsStruct>::IsDerived, "TDataStruct must be derived from FLocalNetAnalyticsStruct");
 
 
    TThreadedNetAnalyticsData()
        : ThreadLocalData()
    {
    }
 
    TDataStruct* GetLocalData()
    {
        thread_local TMap<FThreadedNetAnalyticsData*, FLocalNetAnalyticsStruct*> LocalNetAnalyticsMap;
 
        FLocalNetAnalyticsStruct** FoundVal = LocalNetAnalyticsMap.Find(this);
 
        return (FoundVal != nullptr ? static_cast<TDataStruct*>(*FoundVal) : AddLocalData(LocalNetAnalyticsMap));
    }
 
 
protected:
    TDataStruct* AddLocalData(TMap<FThreadedNetAnalyticsData*, FLocalNetAnalyticsStruct*>& LocalNetAnalyticsMap)
    {
        TDataStruct* ReturnVal = new TDataStruct();
 
        thread_local TMap<TNetAnalyticsDataWeakPtr<FThreadedNetAnalyticsData>, FThreadedNetAnalyticsData*> StaleNetAnalyticsTracking;
 
        LocalNetAnalyticsMap.Add(this, ReturnVal);
        StaleNetAnalyticsTracking.Add(StaticCastSharedRef<FThreadedNetAnalyticsData, FNetAnalyticsData, NetAnalyticsThreadSafety>(AsShared()), this);
        ThreadLocalData.Enqueue(ReturnVal);
 
 
        thread_local uint8 LastNetAnalyticsCounter = 0;
 
        uint8 CurNetAnalyticsCounter = GNetAnalyticsCounter;
 
        if (CurNetAnalyticsCounter != LastNetAnalyticsCounter)
        {
            for (auto It=StaleNetAnalyticsTracking.CreateIterator(); It; ++It)
            {
                if (!It.Key().IsValid())
                {
                    LocalNetAnalyticsMap.Remove(It.Value());
                    It.RemoveCurrent();
                }
            }
 
            LastNetAnalyticsCounter = CurNetAnalyticsCounter;
        }
 
        return ReturnVal;
    }
 
    virtual void NotifyFinalRelease() override
    {
        TDataStruct* CurAnalyticsData = nullptr;
 
        while (ThreadLocalData.Dequeue(CurAnalyticsData))
        {
            CurAnalyticsData->CommitAnalytics(*this);
 
            delete CurAnalyticsData;
        }
 
        FThreadedNetAnalyticsData::NotifyFinalRelease();
    }
 
 
protected:
    TQueue<TDataStruct*, EQueueMode::Mpsc> ThreadLocalData;
};
#endif
 
struct FNetAnalyticsDataDeleter
{
    inline void operator()(FNetAnalyticsData* Data)
    {
        if (Data->Aggregator != nullptr)
        {
            Data->NotifyFinalRelease();
        }
 
        delete Data;
    }
};
 
 
class FNetAnalyticsAggregator
{
public:
    NETCORE_API FNetAnalyticsAggregator(TSharedPtr<IAnalyticsProvider> InProvider, FName InNetDriverName);
 
    FNetAnalyticsAggregator() = delete;
 
    NETCORE_API void Init();
 
    NETCORE_API void InitConfig();
 
    NETCORE_API void AppendGameInstanceAttributes(TArray<FAnalyticsEventAttribute>& OutAttributes);
 
    NETCORE_API void SendAnalytics();
 
 
    NETCORE_API TNetAnalyticsDataPtr<> RegisterAnalyticsData_Internal(TNetAnalyticsDataRef<> InData, const FName& InDataName, FString InTypeName);
 
 
    const TSharedPtr<IAnalyticsProvider>& GetAnalyticsProvider()
    {
        return AnalyticsProvider;
    }
 
    FName GetNetDriverName() const
    {
        return NetDriverName;
    }
 
public:
 
    using FAnalyticsAppender = TFunction<void(TArray<FAnalyticsEventAttribute>&)>;  
    NETCORE_API void SetAnalyticsAppender(FAnalyticsAppender AppenderFunction);
 
private:
    TSharedPtr<IAnalyticsProvider> AnalyticsProvider;
 
    FName NetDriverName;
 
    TMap<FName, TNetAnalyticsDataRef<>> AnalyticsDataMap;
 
    TMap<FName, FString> AnalyticsDataTypeMap;
 
    TMap<FName, bool> AnalyticsDataConfigMap;
 
    FAnalyticsAppender AnalyticsAppender;
 
    bool bSentAnalytics;
};