Crash Reporting Popup (#879)

* Initial Draft

- Add draft crash report window on startup

If you want to disable them before/during startup, there is a command line option to force it

* Fixes

- Update language to be more precise, consistent with settings menu
- Actually shut down reporting properly if you disable it
- Fix my silly syntax errors

* Update text & use Sentry consent

---------

Co-authored-by: Luke Street <luke@street.dev>

src/dusk/crash_reporting.cpp

@@ -4,7 +4,6 @@
 #include "dusk/dusk.h"
 #include "dusk/logging.h"
 #include "dusk/main.h"
-#include "dusk/settings.h"
 #include "version.h"
 
 #include <cstdlib>
@@ -13,114 +12,83 @@
 #include <string_view>
 #include <system_error>
 
-#include "SDL3/SDL_filesystem.h"
-
 #if DUSK_ENABLE_SENTRY_NATIVE
 #include <sentry.h>
 #endif
 
-namespace dusk {
+namespace dusk::crash_reporting {
 
 namespace {
 
 #if DUSK_ENABLE_SENTRY_NATIVE
 bool g_sentryInitialized = false;
 
-bool IsTruthy(std::string_view value) {
-    return value == "1" || value == "true" || value == "TRUE" || value == "yes"
-        || value == "YES" || value == "on" || value == "ON";
+bool truthy(std::string_view value) {
+    return value == "1" || value == "true" || value == "TRUE" || value == "yes" || value == "YES" ||
+           value == "on" || value == "ON";
 }
 
-std::string GetEnvOrEmpty(const char* name) {
+std::string env_or_empty(const char* name) {
     if (const char* value = std::getenv(name)) {
         return value;
     }
     return {};
 }
 
-bool GetEffectiveEnabled() {
-    const std::string env = GetEnvOrEmpty("DUSK_SENTRY_ENABLED");
-    if (!env.empty()) {
-        return IsTruthy(env);
-    }
-    return getSettings().backend.enableCrashReporting;
+bool disabled_by_env() {
+    const std::string env = env_or_empty("DUSK_SENTRY_ENABLED");
+    return !env.empty() && !truthy(env);
 }
 
-std::string GetEffectiveDsn() {
-    const std::string env = GetEnvOrEmpty("DUSK_SENTRY_DSN");
+std::string effective_dsn() {
+    const std::string env = env_or_empty("DUSK_SENTRY_DSN");
     if (!env.empty()) {
         return env;
     }
     return DUSK_SENTRY_DSN;
 }
 
-bool GetEffectiveDebug() {
-    const std::string env = GetEnvOrEmpty("DUSK_SENTRY_DEBUG");
+bool effective_debug() {
+    const std::string env = env_or_empty("DUSK_SENTRY_DEBUG");
     if (!env.empty()) {
-        return IsTruthy(env);
+        return truthy(env);
     }
     return false;
 }
 
-std::string GetReleaseName() {
+std::string release_name() {
     return std::string(AppName) + "@" DUSK_WC_DESCRIBE;
 }
 
-std::filesystem::path GetSentryDatabasePath() {
+std::filesystem::path sentry_database_path() {
     return dusk::ConfigPath / "sentry";
 }
 
-std::filesystem::path GetLogAttachmentPath() {
+std::filesystem::path log_attachment_path() {
     if (const char* logPath = GetLogFilePath()) {
         return logPath;
     }
     return {};
 }
 
-std::filesystem::path GetCrashpadHandlerPath() {
-    const char* basePath = SDL_GetBasePath();
-    if (!basePath) {
-        return {};
-    }
-
-    const std::filesystem::path handlerDir(basePath);
-#if _WIN32
-    return handlerDir / "crashpad_handler.exe";
-#else
-    return handlerDir / "crashpad_handler";
-#endif
-}
-
-void ConfigurePathOptions(sentry_options_t* options) {
-    const auto databasePath = GetSentryDatabasePath();
+void configure_path_options(sentry_options_t* options) {
+    const auto databasePath = sentry_database_path();
     std::error_code ec;
     std::filesystem::create_directories(databasePath, ec);
     if (ec) {
-        DuskLog.warn("Unable to create Sentry database path '{}': {}",
-                     databasePath.string(), ec.message());
+        DuskLog.warn(
+            "Unable to create Sentry database path '{}': {}", databasePath.string(), ec.message());
     }
 
 #if _WIN32
     const std::wstring databasePathWide = databasePath.wstring();
     sentry_options_set_database_pathw(options, databasePathWide.c_str());
-
-    const auto handlerPath = GetCrashpadHandlerPath();
-    if (!handlerPath.empty()) {
-        const std::wstring handlerPathWide = handlerPath.wstring();
-        sentry_options_set_handler_pathw(options, handlerPathWide.c_str());
-    }
 #else
     const std::string databasePathUtf8 = databasePath.string();
     sentry_options_set_database_path(options, databasePathUtf8.c_str());
-
-    const auto handlerPath = GetCrashpadHandlerPath();
-    if (!handlerPath.empty()) {
-        const std::string handlerPathUtf8 = handlerPath.string();
-        sentry_options_set_handler_path(options, handlerPathUtf8.c_str());
-    }
 #endif
 
-    const auto logPath = GetLogAttachmentPath();
+    const auto logPath = log_attachment_path();
     if (!logPath.empty()) {
 #if _WIN32
         sentry_options_add_attachmentw(options, logPath.wstring().c_str());
@@ -133,32 +101,29 @@ void ConfigurePathOptions(sentry_options_t* options) {
 
 }  // namespace
 
-void InitializeCrashReporting() {
+void initialize() {
 #if DUSK_ENABLE_SENTRY_NATIVE
-    if (g_sentryInitialized) {
+    if (g_sentryInitialized || disabled_by_env()) {
         return;
     }
 
-    if (!GetEffectiveEnabled()) {
-        return;
-    }
-
-    const std::string dsn = GetEffectiveDsn();
+    const std::string dsn = effective_dsn();
     if (dsn.empty()) {
         DuskLog.warn("Crash reporting is enabled but no Sentry DSN is configured");
         return;
     }
 
-    const std::string release = GetReleaseName();
+    const std::string release = release_name();
 
     sentry_options_t* options = sentry_options_new();
     sentry_options_set_dsn(options, dsn.c_str());
     sentry_options_set_release(options, release.c_str());
     sentry_options_set_environment(options, DUSK_SENTRY_ENVIRONMENT);
-    sentry_options_set_debug(options, GetEffectiveDebug() ? 1 : 0);
+    sentry_options_set_debug(options, effective_debug() ? 1 : 0);
+    sentry_options_set_require_user_consent(options, 1);
     sentry_options_set_cache_keep(options, 1);
     sentry_options_set_max_breadcrumbs(options, 100);
-    ConfigurePathOptions(options);
+    configure_path_options(options);
 
     if (sentry_init(options) != 0) {
         DuskLog.warn("Failed to initialize Sentry crash reporting");
@@ -173,7 +138,7 @@ void InitializeCrashReporting() {
 #endif
 }
 
-void ShutdownCrashReporting() {
+void shutdown() {
 #if DUSK_ENABLE_SENTRY_NATIVE
     if (!g_sentryInitialized) {
         return;
@@ -184,4 +149,40 @@ void ShutdownCrashReporting() {
 #endif
 }
 
-}  // namespace dusk
+Consent get_consent() {
+#if DUSK_ENABLE_SENTRY_NATIVE
+    if (!g_sentryInitialized) {
+        return Consent::Unavailable;
+    }
+
+    switch (sentry_user_consent_get()) {
+    case SENTRY_USER_CONSENT_GIVEN:
+        return Consent::Given;
+    case SENTRY_USER_CONSENT_REVOKED:
+        return Consent::Revoked;
+    case SENTRY_USER_CONSENT_UNKNOWN:
+    default:
+        return Consent::Unknown;
+    }
+#else
+    return Consent::Unavailable;
+#endif
+}
+
+void set_consent(bool enabled) {
+#if DUSK_ENABLE_SENTRY_NATIVE
+    if (!g_sentryInitialized) {
+        return;
+    }
+
+    if (enabled) {
+        sentry_user_consent_give();
+    } else {
+        sentry_user_consent_revoke();
+    }
+#else
+    (void)enabled;
+#endif
+}
+
+}  // namespace dusk::crash_reporting