TelemetryRouter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Delegates/Delegate.h"
#include "HAL/CriticalSection.h"
#include "Templates/Models.h"
#include "Memory/MemoryView.h"
#include "Misc/Guid.h"
 
#include <type_traits>
 
namespace UE::Telemetry::Private
{
    template<typename DATA_TYPE, typename = void>
    constexpr bool HasTelemetryID = false;
 
    template<typename DATA_TYPE>
    constexpr bool HasTelemetryID<
        DATA_TYPE,
        std::enable_if_t<std::is_same_v<std::decay_t<decltype(DATA_TYPE::TelemetryID)>, FGuid>>> = true;
    
    template <typename DATA_TYPE>
    auto GetDataKeyInternal()
    {
        if constexpr (HasTelemetryID<DATA_TYPE>)
        {
            return DATA_TYPE::TelemetryID;
        }
        else
        {
            return FGuid{};
        }
    }
 
    template <typename DATA_TYPE>
    FGuid GetDataKey() 
    {
        static_assert(HasTelemetryID<DATA_TYPE>, 
            "Unsupported type for telemetry router, must have a static constexpr FGuid member TelemetryID");
        // Silence duplicate compiler error that's less helpful than the static assert
        if constexpr (HasTelemetryID<DATA_TYPE>)
        {
            return DATA_TYPE::TelemetryID;
        }
        else
        {
            return FGuid{};
        }
    }
}
 
class FTelemetryRouter 
{
public:
    FTelemetryRouter();
    ~FTelemetryRouter();
    
    static TELEMETRYUTILS_API FTelemetryRouter& Get();
 
    template<typename DATA_TYPE>
    inline void ProvideTelemetry(const DATA_TYPE& Data)
    {
        ProvideTelemetryInternal(UE::Telemetry::Private::GetDataKey<DATA_TYPE>(), MakeMemoryView(&Data, sizeof(DATA_TYPE)));
    }
    
    template<typename DATA_TYPE>
    inline FDelegateHandle OnTelemetry(TDelegate<void(const DATA_TYPE&)> Sink)
    {
        check(Sink.IsBound());
        FDelegateHandle Handle = Sink.GetHandle();
        RegisterTelemetrySinkInternal(UE::Telemetry::Private::GetDataKey<DATA_TYPE>(), sizeof(DATA_TYPE), Handle,
            [Sink=MoveTemp(Sink)](FMemoryView Data) -> bool {
                return Sink.ExecuteIfBound(*reinterpret_cast<const DATA_TYPE*>(Data.GetData()));
            });
        return Handle;
    }
 
    template<typename DATA_TYPE, typename CALLABLE,
        typename = std::enable_if_t<std::is_invocable_v<CALLABLE, const DATA_TYPE&>>
    >
    inline FDelegateHandle OnTelemetry(CALLABLE&& Sink)
    {
        FDelegateHandle Handle{ FDelegateHandle::GenerateNewHandle };
        RegisterTelemetrySinkInternal(UE::Telemetry::Private::GetDataKey<DATA_TYPE>(), sizeof(DATA_TYPE), Handle,
            [Sink=MoveTemp(Sink)](FMemoryView Data) -> bool {
                Sink(*reinterpret_cast<const DATA_TYPE*>(Data.GetData()));
                return true;
            });
        return Handle;
    }
    
    template<typename DATA_TYPE>
    inline void UnregisterTelemetrySink(FDelegateHandle Handle)
    {
        UnregisterTelemetrySinkInternal(UE::Telemetry::Private::GetDataKey<DATA_TYPE>(), Handle);
    }
    
private:
    TELEMETRYUTILS_API void RegisterTelemetrySinkInternal(FGuid Key, SIZE_T ExpectedSize, FDelegateHandle InHandle, TFunction<bool(FMemoryView)> Sink);
    TELEMETRYUTILS_API void UnregisterTelemetrySinkInternal(FGuid Key, FDelegateHandle InHandle);
    TELEMETRYUTILS_API void ProvideTelemetryInternal(FGuid Key, FMemoryView Data);
    TELEMETRYUTILS_API void CheckNotReentrant();
    
    FRWLock SinkLock;
    
    struct FSinkSet
    {
        SIZE_T DataSize;
        TMap<FDelegateHandle, TFunction<bool(FMemoryView)>> Delegates;
        
        FSinkSet(SIZE_T InDataSize)
            : DataSize(InDataSize)
        {
        }
    };
 
    TMap<FGuid, FSinkSet> KeyToSinks;
};