bSendUnattendedBugReports

bSendUnattendedBugReports

#Overview

name: bSendUnattendedBugReports

The value of this variable can be defined or overridden in .ini config files. 1 .ini config file referencing this setting variable.

It is referenced in 29 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of bSendUnattendedBugReports is to control whether the Unreal Engine should automatically send bug reports to Epic Games without user intervention when crashes or errors occur in unattended scenarios.

This setting variable is primarily used by the crash reporting and analytics systems within Unreal Engine. It is referenced in various modules, including:

  1. The Zen module (Developer/Zen)
  2. The UnrealEd module (Editor/UnrealEd)
  3. The Core module (Runtime/Core)
  4. The CrashReportClient program

The value of this variable is typically set in the engine configuration files, specifically in the GEditorSettingsIni file under the “/Script/UnrealEd.CrashReportsPrivacySettings” section. It can be modified through the engine’s settings interface or directly in the configuration files.

This variable interacts with other privacy and crash reporting settings, such as bSendUsageData and bNoDialog. It is often used in conjunction with these variables to determine the appropriate behavior for crash reporting in different scenarios.

Developers should be aware that:

  1. This setting affects the privacy of users and the collection of crash data.
  2. It behaves differently in editor builds compared to non-editor builds.
  3. In some cases, it may be overridden or ignored based on other conditions (e.g., running as a dedicated server).

Best practices when using this variable include:

  1. Clearly communicating to users how this setting affects their privacy and data collection.
  2. Providing an easy way for users to modify this setting.
  3. Respecting the user’s choice and not overriding it without good reason.
  4. Considering the implications of this setting on different build types (editor, game, server, etc.).
  5. Regularly reviewing and updating privacy policies related to crash reporting and data collection.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEditorSettings.ini:14, section: [/Script/UnrealEd.CrashReportsPrivacySettings]

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Source/Developer/Zen/Private/ZenServerInterface.cpp:947

Scope (from outer to inner):

file
namespace    UE::Zen
function     bool FServiceSettings::ReadFromConfig

Source code excerpt:

			ApplyProcessLifetimeOverride(AutoLaunchSettings.bLimitProcessLifetime);
			EnsureEditorSettingsConfigLoaded();
			GConfig->GetBool(TEXT("/Script/UnrealEd.CrashReportsPrivacySettings"), TEXT("bSendUnattendedBugReports"), AutoLaunchSettings.bSendUnattendedBugReports, GEditorSettingsIni);
		}
	}
	else
	{
		// ConnectExisting settings
		const TCHAR* ConnectExistingConfigSection = TEXT("Zen.ConnectExisting");

#Loc: <Workspace>/Engine/Source/Developer/Zen/Private/ZenServerInterface.cpp:982

Scope (from outer to inner):

file
namespace    UE::Zen
function     bool FServiceSettings::ReadFromCompactBinary

Source code excerpt:

				AutoLaunchSettings.bLimitProcessLifetime = AutoLaunchSettingsObject["LimitProcessLifetime"].AsBool();
				ApplyProcessLifetimeOverride(AutoLaunchSettings.bLimitProcessLifetime);
				AutoLaunchSettings.bSendUnattendedBugReports = AutoLaunchSettingsObject["SendUnattendedBugReports"].AsBool();
				AutoLaunchSettings.bIsDefaultSharedRunContext = AutoLaunchSettingsObject["IsDefaultSharedRunContext"].AsBool(AutoLaunchSettings.bIsDefaultSharedRunContext);
			}
		}
	}
	else
	{

#Loc: <Workspace>/Engine/Source/Developer/Zen/Private/ZenServerInterface.cpp:1042

Scope (from outer to inner):

file
namespace    UE::Zen
function     void FServiceSettings::WriteToCompactBinary

Source code excerpt:

		Writer << "IsDefaultDataPath" << AutoLaunchSettings.bIsDefaultDataPath;
		Writer << "LimitProcessLifetime" << AutoLaunchSettings.bLimitProcessLifetime;
		Writer << "SendUnattendedBugReports" << AutoLaunchSettings.bSendUnattendedBugReports;
		Writer << "IsDefaultSharedRunContext" << AutoLaunchSettings.bIsDefaultSharedRunContext;
		Writer.EndObject();
	}
	else
	{
		const FServiceConnectSettings& ConnectExistingSettings = SettingsVariant.Get<FServiceConnectSettings>();

#Loc: <Workspace>/Engine/Source/Developer/Zen/Private/ZenServerInterface.cpp:1634

Scope (from outer to inner):

file
namespace    UE::Zen
function     static FString DetermineCmdLineWithoutTransientComponents

Source code excerpt:

	}

	if (!InSettings.bSendUnattendedBugReports)
	{
		Parms.Append(TEXT(" --no-sentry"));
	}

	return Parms;
}

#Loc: <Workspace>/Engine/Source/Developer/Zen/Public/Experimental/ZenServerInterface.h:44

Scope (from outer to inner):

file
namespace    UE::Zen

Source code excerpt:

	bool bIsDefaultDataPath = false;
	bool bLimitProcessLifetime = false;
	bool bSendUnattendedBugReports = false;
	bool bIsDefaultSharedRunContext = true;
};

struct FServiceSettings
{
	TVariant<FServiceAutoLaunchSettings, FServiceConnectSettings> SettingsVariant;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Classes/Analytics/CrashReportsPrivacySettings.h:22

Scope (from outer to inner):

file
class        class UCrashReportsPrivacySettings : public UObject, public IImportantToggleSettingInterface

Source code excerpt:

	/** Determines whether the editor automatically sends some bug reports Epic Games in order to improve Unreal Engine. Your information will never be shared with 3rd parties. */
	UPROPERTY(EditAnywhere, config, Category=Options)
	bool bSendUnattendedBugReports;

public:

	// BEGIN IImportantToggleSettingInterface
	virtual void GetToggleCategoryAndPropertyNames(FName& OutCategory, FName& OutProperty) const override;
	virtual FText GetFalseStateLabel() const override;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Analytics/CrashReportsPrivacySettings.cpp:11

Scope (from outer to inner):

file
function     UCrashReportsPrivacySettings::UCrashReportsPrivacySettings

Source code excerpt:

UCrashReportsPrivacySettings::UCrashReportsPrivacySettings(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
	, bSendUnattendedBugReports(false)
{
	if (GConfig)
	{
		GConfig->GetBool(TEXT("/Script/UnrealEd.CrashReportsPrivacySettings"), TEXT("bSendUnattendedBugReports"), bSendUnattendedBugReports, GEditorSettingsIni);
	}
}

void UCrashReportsPrivacySettings::GetToggleCategoryAndPropertyNames(FName& OutCategory, FName& OutProperty) const
{
	OutCategory = FName("Options");

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Analytics/CrashReportsPrivacySettings.cpp:69

Scope (from outer to inner):

file
function     void UCrashReportsPrivacySettings::PostEditChangeProperty

Source code excerpt:

{
	const FName PropertyName = (PropertyChangedEvent.Property != nullptr) ? PropertyChangedEvent.Property->GetFName() : NAME_None;
	if (PropertyName == GET_MEMBER_NAME_CHECKED(UCrashReportsPrivacySettings, bSendUnattendedBugReports))
	{
		FCrashOverrideParameters Params;
		Params.bSetCrashReportClientMessageText = false;
		Params.bSetGameNameSuffix = false;
		Params.SendUnattendedBugReports = bSendUnattendedBugReports;

		FCoreDelegates::CrashOverrideParamsChanged.Broadcast(Params);
	}
}
#endif

#Loc: <Workspace>/Engine/Source/Programs/CrashReportClient/Private/CrashReportClientApp.cpp:954

Scope (from outer to inner):

file
function     static bool LoadTempCrashContextFromFile

Source code excerpt:


	FindAndParseValue(ContextProperties, TEXT("NoDialog"), UserSettings.bNoDialog);
	FindAndParseValue(ContextProperties, TEXT("SendUnattendedBugReports"), UserSettings.bSendUnattendedBugReports);
	FindAndParseValue(ContextProperties, TEXT("SendUsageData"), UserSettings.bSendUsageData);
	FindAndCopyValue(ContextProperties, TEXT("LogFilePath"), UserSettings.LogFilePath);

	return true;
}

#Loc: <Workspace>/Engine/Source/Programs/CrashReportClient/Private/CrashReportClientApp.cpp:1202

Scope (from outer to inner):

file
function     void RunCrashReportClient

Source code excerpt:

					}
#endif
					const bool bNoDialog = (CrashContext.UserSettings.bNoDialog || CrashContext.UserSettings.bImplicitSend) && CrashContext.UserSettings.bSendUnattendedBugReports;
					FCrashReportAnalyticsSessionSummary::Get().OnCrashReportProcessing(/*bIsUserInteractive*/!bNoDialog);
					const SubmitCrashReportResult Result = SendErrorReport(ErrorReport, bNoDialog, CrashContext.UserSettings.bImplicitSend);

					if (bReportCrashAnalyticInfo)
					{
						if (FCrashReportAnalytics::IsAvailable())

#Loc: <Workspace>/Engine/Source/Programs/CrashReportClient/Private/CrashReportClientApp.cpp:1263

Scope (from outer to inner):

file
function     void RunCrashReportClient
lambda-function

Source code excerpt:

					auto HandleAbnormalShutdownFunc = [&TempCrashContext, &RecoveryServicePtr, &ExitCodeOpt]()
					{
						if (TempCrashContext.UserSettings.bSendUnattendedBugReports)
						{
							// Send a spoofed crash report in the case that we detect an abnormal shutdown has occurred
							HandleAbnormalShutdown(TempCrashContext, MonitorPid, MonitorWritePipe, RecoveryServicePtr, ExitCodeOpt);
						}
					};

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/GenericPlatform/GenericPlatformCrashContext.cpp:499

Scope (from outer to inner):

file
function     void FGenericCrashContext::Initialize
lambda-function

Source code excerpt:

		if (InParams.SendUnattendedBugReports.IsSet())
		{
			NCached::UserSettings.bSendUnattendedBugReports = InParams.SendUnattendedBugReports.GetValue();
		}
		if (InParams.SendUsageData.IsSet())
		{
			NCached::UserSettings.bSendUsageData = InParams.SendUsageData.GetValue();
		}
		SerializeTempCrashContextToFile();

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/GenericPlatform/GenericPlatformCrashContext.cpp:725

Scope (from outer to inner):

file
function     void FGenericCrashContext::InitializeFromConfig

Source code excerpt:

#if WITH_EDITOR
	// Set privacy settings -> WARNING: Ensure those setting have a default values in Engine/Config/BaseEditorSettings.ini file, otherwise, they will not be found.
	GConfig->GetBool(TEXT("/Script/UnrealEd.CrashReportsPrivacySettings"), TEXT("bSendUnattendedBugReports"), NCached::UserSettings.bSendUnattendedBugReports, GEditorSettingsIni);
	GConfig->GetBool(TEXT("/Script/UnrealEd.AnalyticsPrivacySettings"), TEXT("bSendUsageData"), NCached::UserSettings.bSendUsageData, GEditorSettingsIni);
#elif CRASH_REPORTER_WITH_ANALYTICS
	NCached::UserSettings.bSendUnattendedBugReports = true; // Give CRC permission to generate and send an 'AbnormalShutdown' report if the application died suddently, mainly to collect the logs post-mortem and count those occurrences.
	NCached::UserSettings.bSendUsageData = true; // Give CRC permission to send its analytics and the application session summary (if one exist)
#endif
	
	// Write a marker file to disk indicating the user has allowed unattended crash reports being
	// sent. This allows us to submit reports for crashes during static initialization when user
	// settings are not available. 
	FString MarkerFilePath = FPaths::Combine(FPlatformProcess::ApplicationSettingsDir(), TEXT("NotAllowedUnattendedBugReports"));
	if (!NCached::UserSettings.bSendUnattendedBugReports)
	{
		TUniquePtr<IFileHandle> File(FPlatformFileManager::Get().GetPlatformFile().OpenWrite(*MarkerFilePath));
	}

	// Make sure we get updated text once the localized version is loaded
	FTextLocalizationManager::Get().OnTextRevisionChangedEvent.AddStatic(&UpdateLocalizedStrings);

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/GenericPlatform/GenericPlatformCrashContext.cpp:1005

Scope (from outer to inner):

file
function     void FGenericCrashContext::SerializeUserSettings

Source code excerpt:

{
	AddCrashPropertyInternal(Buffer, TEXT("NoDialog"), NCached::UserSettings.bNoDialog);
	AddCrashPropertyInternal(Buffer, TEXT("SendUnattendedBugReports"), NCached::UserSettings.bSendUnattendedBugReports);
	AddCrashPropertyInternal(Buffer, TEXT("SendUsageData"), NCached::UserSettings.bSendUsageData);
	AddCrashPropertyInternal(Buffer, FGenericCrashContext::LogFilePathTag, FPlatformOutputDevices::GetAbsoluteLogFilename()); // Don't use the value cached, it may be out of date.
}

// This function may be called in the crashing executable or in an external crash reporter program. Take care with accessing global variables vs member variables or 
// fields in NCached!

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Mac/MacPlatformMisc.cpp:2336

Scope (from outer to inner):

file
function     void FMacCrashContext::GenerateCrashInfoAndLaunchReporter

Source code excerpt:

	}

	bool bSendUnattendedBugReports = true;
	if (GConfig)
	{
		GConfig->GetBool(TEXT("/Script/UnrealEd.CrashReportsPrivacySettings"), TEXT("bSendUnattendedBugReports"), bSendUnattendedBugReports, GEditorSettingsIni);
	}

	bool bSendUsageData = true;
	if (GConfig)
	{
		GConfig->GetBool(TEXT("/Script/UnrealEd.AnalyticsPrivacySettings"), TEXT("bSendUsageData"), bSendUsageData, GEditorSettingsIni);

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Mac/MacPlatformMisc.cpp:2353

Scope (from outer to inner):

file
function     void FMacCrashContext::GenerateCrashInfoAndLaunchReporter

Source code excerpt:

	{
		// do not send unattended reports in licensees' builds except for the editor, where it is governed by the above setting
		bSendUnattendedBugReports = false;
		bSendUsageData = false;
	}

	const bool bUnattended = GMacAppInfo.bIsUnattended || IsRunningDedicatedServer();
	if (bUnattended && !bSendUnattendedBugReports)
	{
		bCanRunCrashReportClient = false;
	}

	if(bCanRunCrashReportClient)
	{

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Mac/MacPlatformMisc.cpp:2470

Scope (from outer to inner):

file
function     void FMacCrashContext::GenerateEnsureInfoAndLaunchReporter

Source code excerpt:

	bool bCanRunCrashReportClient = FCString::Stristr( *(GMacAppInfo.ExecutableName), TEXT( "CrashReportClient" ) ) == nullptr;
	
	bool bSendUnattendedBugReports = true;
	if (GConfig)
	{
		GConfig->GetBool(TEXT("/Script/UnrealEd.CrashReportsPrivacySettings"), TEXT("bSendUnattendedBugReports"), bSendUnattendedBugReports, GEditorSettingsIni);
	}

	bool bSendUsageData = true;
	if (GConfig)
	{
		GConfig->GetBool(TEXT("/Script/UnrealEd.AnalyticsPrivacySettings"), TEXT("bSendUsageData"), bSendUsageData, GEditorSettingsIni);

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Mac/MacPlatformMisc.cpp:2487

Scope (from outer to inner):

file
function     void FMacCrashContext::GenerateEnsureInfoAndLaunchReporter

Source code excerpt:

	{
		// do not send unattended reports in licensees' builds except for the editor, where it is governed by the above setting
		bSendUnattendedBugReports = false;
		bSendUsageData = false;
	}

	const bool bUnattended = GMacAppInfo.bIsUnattended || !IsInteractiveEnsureMode() || IsRunningDedicatedServer();
	if (bUnattended && !bSendUnattendedBugReports)
	{
		bCanRunCrashReportClient = false;
	}

	if(bCanRunCrashReportClient)
	{

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Unix/UnixPlatformCrashContext.cpp:533

Scope (from outer to inner):

file
function     void FUnixCrashContext::GenerateCrashInfoAndLaunchReporter

Source code excerpt:


	/* Table showing the desired behavior when wanting to start the CRC or not.
	 *  based on an *.ini setting for bSendUnattendedBugReports or bAgreeToCrashUpload and whether or not we are unattended
	 *
	 *  Unattended | AgreeToUpload | SendUnattendedBug || Start CRC
	 *  ------------------------------------------------------------
	 *      1      |       1       |         1         ||     1
	 *      1      |       1       |         0         ||     1
	 *      1      |       0       |         1         ||     1
	 *      1      |       0       |         0         ||     0
	 *      0      |       1       |         1         ||     1
	 *      0      |       1       |         0         ||     1
	 *      0      |       0       |         1         ||     1
	 *      0      |       0       |         0         ||     1
	 *
	 */

	// Suppress the user input dialog if we're running in unattended mode
	bool bUnattended = FApp::IsUnattended() || (!IsInteractiveEnsureMode() && bReportingNonCrash) || IsRunningDedicatedServer();

#if PLATFORM_LINUX
	// On Linux, count not having a X11 display as also running unattended, because CRC will switch to the unattended mode in that case
	if (!bUnattended)

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Unix/UnixPlatformCrashContext.cpp:571

Scope (from outer to inner):

file
function     void FUnixCrashContext::GenerateCrashInfoAndLaunchReporter

Source code excerpt:


	// By default we wont upload unless the *.ini has set this to true
	bool bSendUnattendedBugReports = false;
	if (GConfig)
	{
		GConfig->GetBool(TEXT("/Script/UnrealEd.CrashReportsPrivacySettings"), TEXT("bSendUnattendedBugReports"), bSendUnattendedBugReports, GEditorSettingsIni);
	}

	// Controls if we want analytics in the crash report client
	bool bSendUsageData = true;
	if (GConfig)
	{

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Unix/UnixPlatformCrashContext.cpp:594

Scope (from outer to inner):

file
function     void FUnixCrashContext::GenerateCrashInfoAndLaunchReporter

Source code excerpt:

	{
		// do not send unattended reports in licensees' builds except for the editor, where it is governed by the above setting
		bSendUnattendedBugReports = false;
		bAgreeToCrashUpload = false;
		bSendUsageData = false;
	}

	bool bSkipCRC = bUnattended && !bSendUnattendedBugReports && !bAgreeToCrashUpload;

	if (!bSkipCRC)
	{
		const TCHAR* TypeString = TEXT("crash");
		switch(Type)
		{

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Windows/WindowsPlatformCrashContext.cpp:609

Scope (from outer to inner):

file
namespace    anonymous
function     int32 ReportCrashForMonitor

Source code excerpt:

	bool bNoDialog = ReportUI == EErrorReportUI::ReportInUnattendedMode;
	bNoDialog |= UE::Core::Private::CVarForceCrashReportDialogOff.GetValueOnAnyThread() == true;
	bool bSendUnattendedBugReports = true;
	bool bSendUsageData = true;
	bool bCanSendCrashReport = true;
	// Some projects set this value in non editor builds to automatically send error reports unattended, but display
	// a plain message box in the crash report client. See CRC app code for details.
	bool bImplicitSend = false;
	// IsRunningDedicatedServer will check command line arguments, but only for editor builds.

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Windows/WindowsPlatformCrashContext.cpp:633

Scope (from outer to inner):

file
namespace    anonymous
function     int32 ReportCrashForMonitor

Source code excerpt:

	if (GConfig)
	{
		GConfig->GetBool(TEXT("/Script/UnrealEd.CrashReportsPrivacySettings"), TEXT("bSendUnattendedBugReports"), bSendUnattendedBugReports, GEditorSettingsIni);
		GConfig->GetBool(TEXT("/Script/UnrealEd.AnalyticsPrivacySettings"), TEXT("bSendUsageData"), bSendUsageData, GEditorSettingsIni);
		
#if !UE_EDITOR
		if (ReportUI != EErrorReportUI::ReportInUnattendedMode)
		{
			// Only check if we are in a non-editor build

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Windows/WindowsPlatformCrashContext.cpp:652

Scope (from outer to inner):

file
namespace    anonymous
function     int32 ReportCrashForMonitor

Source code excerpt:

		if (::PathFileExistsW(*NotAllowedUnattendedBugReportMarkerPath))
		{
			bSendUnattendedBugReports = false;
		}
	}

#if !UE_EDITOR
	// NOTE: A blueprint-only game packaged from a vanilla engine downloaded from Epic Game Store isn't considered a 'Licensee' version because the engine was built by Epic.
	//       There is no way at the moment do distinguish this case properly.

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Windows/WindowsPlatformCrashContext.cpp:662

Scope (from outer to inner):

file
namespace    anonymous
function     int32 ReportCrashForMonitor

Source code excerpt:

	{
		// do not send unattended reports in licensees' builds except for the editor, where it is governed by the above setting
		bSendUnattendedBugReports = false;
		bSendUsageData = false;
	}
#endif

	if (bNoDialog && !bSendUnattendedBugReports)
	{
		// If we shouldn't display a dialog (like for ensures) and the user
		// does not allow unattended bug reports we cannot send the report.
		bCanSendCrashReport = false;
	}

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Windows/WindowsPlatformCrashContext.cpp:680

Scope (from outer to inner):

file
namespace    anonymous
function     int32 ReportCrashForMonitor

Source code excerpt:


	SharedContext->UserSettings.bNoDialog = bNoDialog;
	SharedContext->UserSettings.bSendUnattendedBugReports = bSendUnattendedBugReports;
	SharedContext->UserSettings.bSendUsageData = bSendUsageData;
	SharedContext->UserSettings.bImplicitSend = bImplicitSend;

	SharedContext->SessionContext.bIsExitRequested = IsEngineExitRequested();
	FCString::Strncpy(SharedContext->ErrorMessage, ErrorMessage, CR_MAX_ERROR_MESSAGE_CHARS);

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Windows/WindowsPlatformCrashContext.cpp:832

Scope (from outer to inner):

file
namespace    anonymous
function     int32 ReportCrashUsingCrashReportClient

Source code excerpt:

#endif

	bool bSendUnattendedBugReports = true;
	if (GConfig)
	{
		GConfig->GetBool(TEXT("/Script/UnrealEd.CrashReportsPrivacySettings"), TEXT("bSendUnattendedBugReports"), bSendUnattendedBugReports, GEditorSettingsIni);
	}

	// Controls if we want analytics in the crash report client
	bool bSendUsageData = true;
	if (GConfig)
	{

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Windows/WindowsPlatformCrashContext.cpp:851

Scope (from outer to inner):

file
namespace    anonymous
function     int32 ReportCrashUsingCrashReportClient

Source code excerpt:

	{
		// do not send unattended reports in licensees' builds except for the editor, where it is governed by the above setting
		bSendUnattendedBugReports = false;
		bSendUsageData = false;
	}
#endif

	if (bNoDialog && !bSendUnattendedBugReports)
	{
		bCanRunCrashReportClient = false;
	}

	if( bCanRunCrashReportClient )
	{

#Loc: <Workspace>/Engine/Source/Runtime/Core/Public/GenericPlatform/GenericPlatformCrashContext.h:215

Scope: file

Source code excerpt:

{
	bool					bNoDialog = false;
	bool					bSendUnattendedBugReports = false;
	bool					bSendUsageData = false;
	bool					bImplicitSend = false;
	TCHAR					LogFilePath[CR_MAX_DIRECTORY_CHARS];
};

/**