ref: Event processing (#202)

* Revise event processing to support Android. This fixes missing screenshots and view hierarchy on Android.
* Introduce event processors (internally). This interface can also be later exposed in the public API if needed.

Author: limbonaut

SConstruct

@@ -222,6 +222,7 @@ env.Append(CPPPATH=["src/"])
 sources = Glob("src/*.cpp")
 sources += Glob("src/editor/*.cpp")
 sources += Glob("src/sentry/*.cpp")
+sources += Glob("src/sentry/processing/*.cpp")
 sources += Glob("src/sentry/util/*.cpp")
 # Compile sentry-native code only on respective platforms.
 if env["platform"] in ["linux", "windows", "macos"]:

android_lib/src/main/java/io/sentry/godotplugin/SentryAndroidGodotPlugin.kt

@@ -19,6 +19,7 @@ import org.godotengine.godot.Godot
 import org.godotengine.godot.plugin.GodotPlugin
 import org.godotengine.godot.plugin.UsedByGodot
 import org.godotengine.godot.variant.Callable
+import java.io.File
 import kotlin.random.Random
 
 
@@ -123,8 +124,14 @@ class SentryAndroidGodotPlugin(godot: Godot) : GodotPlugin(godot) {
     }
 
     @UsedByGodot
-    fun addGlobalAttachment(path: String) {
-        val attachment = Attachment(path)
+    fun addFileAttachment(path: String, filename: String, contentType: String, attachmentType: String) {
+        val attachment = Attachment(
+            path,
+            filename.ifEmpty { File(path).name },
+            contentType.ifEmpty { null },
+            attachmentType.ifEmpty { null },
+            false
+        )
         Sentry.getGlobalScope().addAttachment(attachment)
     }
 
@@ -335,6 +342,32 @@ class SentryAndroidGodotPlugin(godot: Godot) : GodotPlugin(godot) {
         getEvent(eventHandle)?.removeTag(key)
     }
 
+    @UsedByGodot
+    fun eventMergeContext(eventHandle: Int, key: String, value: Dictionary) {
+        val event = getEvent(eventHandle) ?: return
+
+        val existingContext: Any? = event.contexts[key]
+
+        if (existingContext is Dictionary) {
+            // Fast path: merge Dictionary directly.
+            existingContext.putAll(value)
+        } else {
+            val existingMap = existingContext as? Map<*, *>
+            existingMap?.let {
+                // Merge elements from existing context into new context, but only for keys
+                // that don't already exist in the new context.
+                for ((k, v) in it) {
+                    val kStr: String = k as? String ?: continue
+                    if (!value.containsKey(kStr)) {
+                        value[kStr] = v
+                    }
+                }
+            }
+            event.contexts[key] = value
+        }
+
+    }
+
     @UsedByGodot
     fun eventIsCrash(eventHandle: Int): Boolean {
         return getEvent(eventHandle)?.isCrashed == true

src/register_types.cpp

@@ -2,9 +2,12 @@
 #include "editor/sentry_editor_plugin.h"
 #include "runtime_config.h"
 #include "sentry/disabled_event.h"
+#include "sentry/processing/screenshot_processor.h"
+#include "sentry/processing/view_hierarchy_processor.h"
 #include "sentry/util/print.h"
 #include "sentry_configuration.h"
 #include "sentry_event.h"
+#include "sentry_event_processor.h"
 #include "sentry_logger.h"
 #include "sentry_options.h"
 #include "sentry_sdk.h"
@@ -67,6 +70,9 @@ void initialize_module(ModuleInitializationLevel p_level) {
 		GDREGISTER_CLASS(SentrySDK);
 		GDREGISTER_ABSTRACT_CLASS(SentryEvent);
 		GDREGISTER_INTERNAL_CLASS(DisabledEvent);
+		GDREGISTER_INTERNAL_CLASS(SentryEventProcessor);
+		GDREGISTER_INTERNAL_CLASS(ScreenshotProcessor);
+		GDREGISTER_INTERNAL_CLASS(ViewHierarchyProcessor);
 		GDREGISTER_INTERNAL_CLASS(SentryLogger);
 
 #ifdef NATIVE_SDK

src/sentry/android/android_event.cpp

@@ -101,6 +101,11 @@ String AndroidEvent::get_tag(const String &p_key) {
 	return android_plugin->call(ANDROID_SN(eventGetTag), event_handle, p_key);
 }
 
+void AndroidEvent::merge_context(const String &p_key, const Dictionary &p_value) {
+	ERR_FAIL_COND_MSG(p_key.is_empty(), "Sentry: Can't merge context with an empty key.");
+	android_plugin->call(ANDROID_SN(eventMergeContext), event_handle, p_key, p_value);
+}
+
 void AndroidEvent::add_exception(const Exception &p_exception) {
 	ERR_FAIL_NULL(android_plugin);
 

src/sentry/android/android_event.h

@@ -49,6 +49,8 @@ class AndroidEvent : public SentryEvent {
 	virtual void remove_tag(const String &p_key) override;
 	virtual String get_tag(const String &p_key) override;
 
+	virtual void merge_context(const String &p_key, const Dictionary &p_value) override;
+
 	virtual void add_exception(const Exception &p_exception) override;
 
 	virtual bool is_crash() const override;

src/sentry/android/android_sdk.cpp

@@ -2,6 +2,7 @@
 
 #include "android_event.h"
 #include "android_string_names.h"
+#include "sentry/processing/process_event.h"
 #include "sentry/util/print.h"
 
 #include <godot_cpp/classes/engine.hpp>
@@ -17,27 +18,15 @@ void SentryAndroidBeforeSendHandler::_initialize(Object *p_android_plugin) {
 
 void SentryAndroidBeforeSendHandler::_before_send(int32_t p_event_handle) {
 	sentry::util::print_debug("handling before_send: ", p_event_handle);
+
 	Ref<AndroidEvent> event_obj = memnew(AndroidEvent(android_plugin, p_event_handle));
 	event_obj->set_as_borrowed();
-	if (const Callable &before_send = SentryOptions::get_singleton()->get_before_send(); before_send.is_valid()) {
-		Ref<AndroidEvent> processed = before_send.call(event_obj);
-		if (processed.is_valid() && processed != event_obj) {
-			static bool first_print = true;
-			if (unlikely(first_print)) {
-				// Note: Only push error once to avoid infinite feedback loop.
-				ERR_PRINT("Sentry: before_send callback must return the same event object or null.");
-				first_print = false;
-			} else {
-				sentry::util::print_error("before_send callback must return the same event object or null.");
-			}
-		}
-		if (processed.is_null()) {
-			// Discard event.
-			sentry::util::print_debug("event discarded by before_send callback: ", event_obj->get_id());
-			android_plugin->call(ANDROID_SN(releaseEvent), p_event_handle);
-		} else {
-			sentry::util::print_debug("event processed by before_send callback: ", event_obj->get_id());
-		}
+
+	Ref<AndroidEvent> processed = sentry::process_event(event_obj);
+
+	if (processed.is_null()) {
+		// Discard event.
+		android_plugin->call(ANDROID_SN(releaseEvent), p_event_handle);
 	}
 }
 
@@ -118,7 +107,13 @@ void AndroidSDK::initialize(const PackedStringArray &p_global_attachments) {
 	sentry::util::print_debug("Initializing Sentry Android SDK");
 
 	for (const String &path : p_global_attachments) {
-		android_plugin->call(ANDROID_SN(addGlobalAttachment), path);
+		String file = path.get_file();
+		bool is_view_hierarchy = file == "view-hierarchy.json";
+		android_plugin->call(ANDROID_SN(addFileAttachment),
+				path,
+				file,
+				is_view_hierarchy ? "application/json" : "",
+				is_view_hierarchy ? "event.view_hierarchy" : "");
 	}
 
 	android_plugin->call("initialize",

src/sentry/android/android_string_names.cpp

@@ -15,7 +15,7 @@ void AndroidStringNames::destroy_singleton() {
 
 AndroidStringNames::AndroidStringNames() {
 	// API methods.
-	addGlobalAttachment = StringName("addGlobalAttachment");
+	addFileAttachment = StringName("addFileAttachment");
 	setContext = StringName("setContext");
 	removeContext = StringName("removeContext");
 	setTag = StringName("setTag");
@@ -50,6 +50,7 @@ AndroidStringNames::AndroidStringNames() {
 	eventSetTag = StringName("eventSetTag");
 	eventRemoveTag = StringName("eventRemoveTag");
 	eventGetTag = StringName("eventGetTag");
+	eventMergeContext = StringName("eventMergeContext");
 	eventIsCrash = StringName("eventIsCrash");
 
 	// Exceptions.

src/sentry/android/android_string_names.h

@@ -27,7 +27,7 @@ class AndroidStringNames {
 	_FORCE_INLINE_ static AndroidStringNames *get_singleton() { return singleton; }
 
 	// API methods.
-	StringName addGlobalAttachment;
+	StringName addFileAttachment;
 	StringName setContext;
 	StringName removeContext;
 	StringName setTag;
@@ -62,6 +62,7 @@ class AndroidStringNames {
 	StringName eventSetTag;
 	StringName eventRemoveTag;
 	StringName eventGetTag;
+	StringName eventMergeContext;
 	StringName eventIsCrash;
 
 	// Exceptions.

src/sentry/disabled_event.h

@@ -49,6 +49,8 @@ class DisabledEvent : public SentryEvent {
 	virtual void remove_tag(const String &p_key) override {}
 	virtual String get_tag(const String &p_key) override { return ""; }
 
+	virtual void merge_context(const String &p_key, const Dictionary &p_value) override {}
+
 	virtual void add_exception(const Exception &p_exception) override {}
 
 	virtual bool is_crash() const override { return false; }

src/sentry/native/native_event.cpp

@@ -17,6 +17,35 @@ inline void _sentry_value_set_or_remove_string_by_key(sentry_value_t value, cons
 	}
 }
 
+void sentry_event_merge_context(sentry_value_t p_event, const char *p_context_name, const Dictionary &p_context) {
+	ERR_FAIL_COND(sentry_value_get_type(p_event) != SENTRY_VALUE_TYPE_OBJECT);
+	ERR_FAIL_COND(p_context_name == nullptr || strlen(p_context_name) == 0);
+
+	if (p_context.is_empty()) {
+		return;
+	}
+
+	sentry_value_t contexts = sentry_value_get_by_key(p_event, "contexts");
+	if (sentry_value_is_null(contexts)) {
+		contexts = sentry_value_new_object();
+		sentry_value_set_by_key(p_event, "contexts", contexts);
+	}
+
+	// Check if context exists and update or add it.
+	sentry_value_t ctx = sentry_value_get_by_key(contexts, p_context_name);
+	if (!sentry_value_is_null(ctx)) {
+		// If context exists, update it with new values.
+		const Array &updated_keys = p_context.keys();
+		for (int i = 0; i < updated_keys.size(); i++) {
+			const String &key = updated_keys[i];
+			sentry_value_set_by_key(ctx, key.utf8(), sentry::native::variant_to_sentry_value(p_context[key]));
+		}
+	} else {
+		// If context doesn't exist, add it.
+		sentry_value_set_by_key(contexts, p_context_name, sentry::native::variant_to_sentry_value(p_context));
+	}
+}
+
 } // unnamed namespace
 
 String NativeEvent::get_id() const {
@@ -141,6 +170,11 @@ String NativeEvent::get_tag(const String &p_key) {
 	return String();
 }
 
+void NativeEvent::merge_context(const String &p_key, const Dictionary &p_value) {
+	ERR_FAIL_COND_MSG(p_key.is_empty(), "Sentry: Can't merge context with an empty key.");
+	sentry_event_merge_context(native_event, p_key.utf8(), p_value);
+}
+
 void NativeEvent::add_exception(const Exception &p_exception) {
 	sentry_value_t native_exception = sentry_value_new_exception(p_exception.type.utf8(), p_exception.value.utf8());
 	sentry_value_t stack_trace = sentry_value_new_object();