CrashDescription.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "GenericPlatform/GenericPlatformCrashContext.h"
#include "HAL/Platform.h"
#include "Misc/CString.h"
#include "Misc/EngineVersion.h"
#include "Templates/Function.h"
#include "XmlFile.h"
#include "XmlNode.h"
 
#if WITH_CRASHREPORTER
#include "CrashDebugHelper.h"
#endif
 
enum class ECrashDescVersions : int32;
enum class ECrashDumpMode : int32;
class FXmlNode;
struct FAnalyticsEventAttribute;
struct FPrimaryCrashProperties;
 
/*
    "CrashVersion"
    "ProcessId"
    "CrashGUID"
    "IsInternalBuild"
    "IsPerforceBuild"
    "IsSourceDistribution"
    "IsEnsure"
    "SecondsSinceStart"
    "GameName"
    "ExecutableName"
    "BuildConfiguration"
    "PlatformName"
    "PlatformNameIni"
    "PlatformFullName"
    "EngineMode"
    "EngineModeEx"
    "EngineVersion"
    "BuildVersion"
    "CommandLine"
    "LanguageLCID"
    "AppDefaultLocale"
    "IsUERelease"
    "UserName"
    "BaseDir"
    "RootDir"
    "MachineId"
    "LoginId"
    "EpicAccountId"
    "CallStack"
    "SourceContext"
    "UserDescription"
    "UserActivityHint"
    "ErrorMessage"
    "CrashDumpMode"
    "CrashReporterMessage"
    "Misc.NumberOfCores"
    "Misc.NumberOfCoresIncludingHyperthreads"
    "Misc.Is64bitOperatingSystem"
    "Misc.CPUVendor"
    "Misc.CPUBrand"
    "Misc.PrimaryGPUBrand"
    "Misc.OSVersionMajor"
    "Misc.OSVersionMinor"
    "Misc.AppDiskTotalNumberOfBytes"
    "Misc.AppDiskNumberOfFreeBytes"
    "MemoryStats.TotalPhysical"
    "MemoryStats.TotalVirtual"
    "MemoryStats.PageSize"
    "MemoryStats.TotalPhysicalGB"
    "MemoryStats.AvailablePhysical"
    "MemoryStats.AvailableVirtual"
    "MemoryStats.UsedPhysical"
    "MemoryStats.PeakUsedPhysical"
    "MemoryStats.UsedVirtual"
    "MemoryStats.PeakUsedVirtual"
    "MemoryStats.bIsOOM"
    "MemoryStats.OOMAllocationSize"
    "MemoryStats.OOMAllocationAlignment"
    "TimeofCrash"
    "bAllowToBeContacted"
 */
 
inline void LexFromString( ECrashDescVersions& OutValue, const TCHAR* Buffer )
{
    OutValue = (ECrashDescVersions)FCString::Atoi( Buffer );
}
 
inline void LexFromString( ECrashDumpMode& OutValue, const TCHAR* Buffer )
{
    OutValue = (ECrashDumpMode)FCString::Atoi( Buffer );
}
 
inline void LexFromString( FEngineVersion& OutValue, const TCHAR* Buffer )
{
    FEngineVersion::Parse( Buffer, OutValue );
}
 
struct FCrashProperty
{
    friend struct FPrimaryCrashProperties;
 
protected:
    FCrashProperty( const FString& InMainCategory, const FString& InSecondCategory, FPrimaryCrashProperties* InOwner );
 
public:
    FCrashProperty& operator=(const FString& NewValue);
 
    FCrashProperty& operator=(const TCHAR* NewValue);
 
    FCrashProperty& operator=(const TArray<FString>& NewValue);
 
    FCrashProperty& operator=(const bool NewValue);
 
    FCrashProperty& operator=(const int64 NewValue);
 
    const FString& AsString() const;
 
    bool AsBool() const;
 
    int64 AsInt64() const;
 
protected:
    FPrimaryCrashProperties* Owner;
 
    mutable FString CachedValue;
 
    FString MainCategory;
 
    FString SecondCategory;
 
    mutable bool bSet;
};
 
struct FCrashPropertyXmlNode
{
    friend struct FPrimaryCrashProperties;
    FCrashPropertyXmlNode& operator=(const FXmlNode* Node);
    
#if WITH_CRASHREPORTER
    FCrashPropertyXmlNode& operator=(const TArray<FCrashThreadInfo>& ThreadsInfo);
#endif
    
protected:
    FCrashPropertyXmlNode(const FString& InMainCategory, const FString& InSecondCategory, FPrimaryCrashProperties* InOwner);
 
protected:
    FPrimaryCrashProperties* Owner;
 
    FString MainCategory;
 
    FString SecondCategory;
 
    mutable bool bSet;
};
 
struct FPrimaryCrashProperties
{
    friend struct FCrashProperty;
    friend struct FCrashPropertyXmlNode;
 
    ECrashDescVersions CrashVersion;
 
    ECrashDumpMode CrashDumpMode;
 
    FString CrashGUID;
 
    FString GameName;
 
    FString ExecutableName;
 
    FString EngineMode;
 
    FString DeploymentName;
 
    FCrashProperty EngineModeEx;
 
    FCrashProperty PlatformFullName;
 
    FEngineVersion EngineVersion;
 
    FCrashProperty CommandLine;
 
    FString BaseDir;
 
    FString AppDefaultLocale;
 
    FCrashProperty UserName;
 
    FCrashProperty LoginId;
 
    FCrashProperty EpicAccountId;
 
    FCrashProperty GameSessionID;
 
    /*
     * A hash representing a unique id for a portable callstack. These will be specific to the CL version of the application
     * @PCallStackHash  varchar(160)
     *
     */
    FString PCallStackHash;
 
    /*
     * The signal that was raised to enter the crash handler
     */
    int32 CrashSignal;
 
    int32 NumMinidumpFramesToIgnore;
 
    FCrashProperty CallStack;
    
    FCrashProperty PCallStack;
    
    FCrashProperty PCallStackHashProperty;
 
    FCrashProperty SourceContext;
 
    FCrashProperty Modules;
 
    FCrashProperty UserDescription;
 
    FCrashProperty UserActivityHint;
 
    FCrashProperty ErrorMessage;
 
    FCrashProperty FullCrashDumpLocation;
 
    FCrashProperty TimeOfCrash;
 
    FCrashProperty bAllowToBeContacted;
 
    FCrashProperty CrashReporterMessage;
 
    FCrashProperty PlatformCallbackResult;
 
    FCrashProperty CrashReportClientVersion;
 
    bool bHasMiniDumpFile;
 
    bool bHasLogFile;
 
    bool bHasPrimaryData;
 
    FString RestartCommandLine;
 
    bool bIsEnsure;
 
    FString CrashType;
 
    FCrashProperty CPUBrand;
 
    FCrashPropertyXmlNode Threads;
 
    FCrashPropertyXmlNode PlatformPropertiesExtras;
 
    bool bIsOOM;
    
    bool bLowMemoryWarning;
    
    bool bInBackground;
 
    bool bIsRequestingExit;
 
    uint32 CrashScreenshotWidth = 0;
    uint32 CrashScreenshotHeight = 0;
 
protected:
    FPrimaryCrashProperties();
 
    ~FPrimaryCrashProperties()
    {
        delete XmlFile;
    }
 
public:
    static void Set( FPrimaryCrashProperties* NewInstance )
    {
        Singleton = NewInstance;
    }
 
    static FPrimaryCrashProperties* Get()
    {
        return Singleton;
    }
 
    static bool IsValid()
    {
        return Singleton != nullptr;
    }
 
    static void Shutdown();
 
    bool HasProcessedData() const
    {
        return CallStack.AsString().Len() > 0 && ErrorMessage.AsString().Len() > 0;
    }
 
    void UpdateIDs();
 
    void SendPreUploadAnalytics();
 
    void SendPostUploadAnalytics(double Duration, bool bResult, int32 ResponseCode, uint32 PayloadSize, uint32 ReportCount);
 
    void Save();
 
protected:
    void ReadXML( const FString& CrashContextFilepath, const TCHAR* Buffer = nullptr );
 
    void SetCrashGUID( const FString& Filepath );
 
    template <typename Type>
    void GetCrashProperty( Type& out_ReadValue, const FString& MainCategory, const FString& SecondCategory ) const
    {
        if (XmlFile->IsValid())
        {
            const FXmlNode* MainNode = XmlFile->GetRootNode()->FindChildNode( MainCategory );
            if (MainNode)
            {
                const FXmlNode* CategoryNode = MainNode->FindChildNode( SecondCategory );
                if (CategoryNode)
                {
                    LexFromString( out_ReadValue, *FGenericCrashContext::UnescapeXMLString( CategoryNode->GetContent() ) );
                }
            }
        }
    }
 
    template <typename Type>
    void SetCrashProperty( const FString& MainCategory, const FString& SecondCategory, const Type& Value )
    {
        SetCrashProperty( MainCategory, SecondCategory, *TTypeToString<Type>::ToString( Value ) );
    }
 
    void SetCrashProperty( const FString& MainCategory, const FString& SecondCategory, const FString& NewValue )
    {
        if (XmlFile->IsValid())
        {
            FXmlNode* MainNode = XmlFile->GetRootNode()->FindChildNode( MainCategory );
            if (MainNode)
            {
                FXmlNode* CategoryNode = MainNode->FindChildNode( SecondCategory );
                FString EscapedValue;
                FGenericCrashContext::AppendEscapedXMLString(EscapedValue, *NewValue);
                if (CategoryNode)
                {
                    CategoryNode->SetContent( EscapedValue );
                }
                else
                {
                    MainNode->AppendChildNode( SecondCategory, EscapedValue );
                }
            }
        }
    }
 
    void SetCrashProperty(const FString& MainCategory, const FString& SecondCategory, const FXmlNode* NewNode)
    {
        if (XmlFile->IsValid())
        {
            FXmlNode* MainNode = XmlFile->GetRootNode()->FindChildNode(MainCategory);
            if (MainNode)
            {
                FXmlNode* CategoryNode = MainNode->FindChildNode(SecondCategory);
                const FString& Content = NewNode->GetContent();
 
                if(!CategoryNode) // can only add.
                {
                    TFunction<void(FXmlNode*, const FXmlNode*)> AppendNode;
                    AppendNode = [&AppendNode](FXmlNode* DestNode, const FXmlNode* SourceNode)
                    {
                        DestNode->AppendChildNode(SourceNode->GetTag(), SourceNode->GetContent());
                        for (const FXmlNode *SourceChild : SourceNode->GetChildrenNodes())
                        {
                            const TArray<FXmlNode *>& DestChildren = DestNode->GetChildrenNodes();
                            AppendNode(DestChildren.Last(), SourceChild);
                        }
                    };
 
                    AppendNode(MainNode, NewNode);
                }
            }
        }
    }
 
 
    FString EncodeArrayStringAsXMLString( const TArray<FString>& ArrayString ) const;
 
    void MakeCrashEventAttributes(TArray<FAnalyticsEventAttribute>& OutCrashAttributes);
 
    FXmlFile* XmlFile;
 
    FString XmlFilepath;
 
    static FPrimaryCrashProperties* Singleton;
};
 
struct FCrashContext : public FPrimaryCrashProperties
{
    explicit FCrashContext( const FString& CrashContextFilepath );
 
    FCrashContext(const FString& CrashContextFilepath, const TCHAR* Buffer);
 
private:
 
    void SetupPrimaryCrashProperties();
};
 
struct FCrashWERContext : public FPrimaryCrashProperties
{
    explicit FCrashWERContext( const FString& WERXMLFilepath );
 
    void InitializeEngineVersion( const FString& BuildVersion, const FString& BranchName, uint32 BuiltFromCL );
};