StudioTelemetry.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Interfaces/IAnalyticsProvider.h"
#include "Interfaces/IAnalyticsTracer.h"
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"
#include "Templates/SharedPointer.h"
 
class FAnalyticsProviderBroadcast;
class FStudioTelemetry : public IModuleInterface
{
public:
 
    typedef TFunction<void(const FString& EventName, const TArray<FAnalyticsEventAttribute>& Attrs)> OnRecordEventCallback;
 
    static bool IsAvailable() { return FStudioTelemetry::Get().IsSessionRunning(); }
 
    static STUDIOTELEMETRY_API FStudioTelemetry& Get();
 
    STUDIOTELEMETRY_API TWeakPtr<IAnalyticsProvider> GetProvider(const FString& ProviderName);
 
    STUDIOTELEMETRY_API TWeakPtr<IAnalyticsProvider> GetProvider();
 
    STUDIOTELEMETRY_API TWeakPtr<IAnalyticsTracer> GetTracer();
 
    STUDIOTELEMETRY_API bool StartSession();
 
    STUDIOTELEMETRY_API void EndSession();
 
    STUDIOTELEMETRY_API bool IsSessionRunning() const;
    
    STUDIOTELEMETRY_API void RecordEvent(const FString& EventName, const TArray<FAnalyticsEventAttribute>& Attributes = {});
 
    STUDIOTELEMETRY_API void RecordEvent(const FName CategoryName, const FString& EventName, const TArray<FAnalyticsEventAttribute>& Attributes = {});
 
    STUDIOTELEMETRY_API void RecordEventToProvider(const FString& ProviderName, const FString& EventName, const TArray<FAnalyticsEventAttribute>& Attributes = {});
 
    STUDIOTELEMETRY_API void FlushEvents();
 
    STUDIOTELEMETRY_API TSharedPtr<IAnalyticsSpan> StartSpan(const FName Name, const TArray<FAnalyticsEventAttribute>& AdditionalAttributes = {});
 
    STUDIOTELEMETRY_API TSharedPtr<IAnalyticsSpan> StartSpan(const FName Name, TSharedPtr<IAnalyticsSpan> ParentSpan, const TArray<FAnalyticsEventAttribute>& AdditionalAttributes = {});
 
    STUDIOTELEMETRY_API bool EndSpan(TSharedPtr<IAnalyticsSpan> Span, const TArray<FAnalyticsEventAttribute>& AdditionalAttributes = {});
 
    STUDIOTELEMETRY_API bool EndSpan(const FName Name, const TArray<FAnalyticsEventAttribute>& AdditionalAttributes = {});
 
    STUDIOTELEMETRY_API TSharedPtr<IAnalyticsSpan> GetSpan(const FName Name);
 
    STUDIOTELEMETRY_API TSharedPtr<IAnalyticsSpan> GetSessionSpan() const;
 
    STUDIOTELEMETRY_API void SetRecordEventCallback(OnRecordEventCallback);
 
    DECLARE_MULTICAST_DELEGATE(FOnStartSession);
    FOnStartSession& GetOnStartSession() { return OnStartSession; }
 
    DECLARE_MULTICAST_DELEGATE(FOnEndSession);
    FOnEndSession& GetOnEndSession() { return OnEndSession; }
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnRecordEvent, const FString&, const TArray<FAnalyticsEventAttribute>&);
    FOnRecordEvent& GetOnRecordEvent() { return OnRecordEvent; }
 
    class FSessionScope
    {
    public:
        FSessionScope()
        {
            FStudioTelemetry::Get().StartSession();
        }
 
        ~FSessionScope()
        {
            FStudioTelemetry::Get().EndSession();
        }
    };
 
    class FSpanScope
    {
    public:
        FSpanScope(const FName Name, const TArray<FAnalyticsEventAttribute>& AdditionalAttributes = {} )
        {
            if (FStudioTelemetry::Get().IsAvailable())
            {
                Span = FStudioTelemetry::Get().StartSpan(Name, AdditionalAttributes);
            }
        }
 
        ~FSpanScope()
        {
            if (FStudioTelemetry::Get().IsAvailable())
            {
                FStudioTelemetry::Get().EndSpan(Span);
            }
        }
    private:
 
        TSharedPtr<IAnalyticsSpan> Span;
    };
 
private:
 
    void LoadConfiguration();
 
    struct FConfig
    {
        bool bSendTelemetry = true; // Only send telemetry data if we have been requested to
        bool bSendUserData = false;  // Never send user data unless specifically asked to
        bool bSendHardwareData = false; // Never send hardware data unless specifically asked to4
        bool bSendOSData = false; // Never send operating system data unless specifically asked to
    };
    
    FCriticalSection                        CriticalSection;
    TSharedPtr<FAnalyticsProviderBroadcast> AnalyticsProvider;
    TSharedPtr<IAnalyticsTracer>            AnalyticsTracer;
    OnRecordEventCallback                   RecordEventCallback;
    FGuid                                   SessionGUID;
    FConfig                                 Config;
    FOnStartSession                         OnStartSession;
    FOnEndSession                           OnEndSession;
    FOnRecordEvent                          OnRecordEvent;
};
 
// Useful macros for scoped sessions and spans
#define STUDIO_TELEMETRY_SESSION_SCOPE FStudioTelemetry::FSessionScope PREPROCESSOR_JOIN(FSessionScope, __LINE__);
#define STUDIO_TELEMETRY_SPAN_SCOPE(Name) FStudioTelemetry::FSpanScope PREPROCESSOR_JOIN(FSpanScope, __LINE__)(TEXT(#Name));
#define STUDIO_TELEMETRY_START_SPAN(Name) if (FStudioTelemetry::Get().IsAvailable()) { FStudioTelemetry::Get().StartSpan(TEXT(#Name));}
#define STUDIO_TELEMETRY_END_SPAN(Name) if (FStudioTelemetry::Get().IsAvailable()) { FStudioTelemetry::Get().EndSpan(TEXT(#Name));}