Sebastian/before send 2

src/manifest.gdextension

@@ -1,6 +1,6 @@
 [configuration]
 
-entry_symbol = "gdextension_init"
+entry_symbol = "sentry_godot_gdextension_init"
 compatibility_minimum = "{compatibility_minimum}"
 
 [libraries]

src/register_types.cpp

@@ -1,3 +1,4 @@
+#include "sentry_godot.h"
 #include "runtime_config.h"
 #include "sentry/disabled_event.h"
 #include "sentry/util/print.h"
@@ -16,74 +17,81 @@
 #include "sentry/native/native_event.h"
 #endif // NATIVE_SDK
 
+#ifdef COCOA_SDK
+#include "sentry/cocoa/cocoa_event.h"
+#endif // COCOA_SDK
+
 using namespace godot;
 
 namespace {
 
 void _init_logger() {
-	if (!SentryOptions::get_singleton()->is_logger_enabled()) {
+	if (!sentry::SentryOptions::get_singleton()->is_logger_enabled()) {
 		// If error logger is disabled, don't add it to the scene tree.
 		sentry::util::print_debug("error logger is disabled in options");
 		return;
 	}
-	if (!SentrySDK::get_singleton()->is_enabled()) {
+	if (!sentry::SentrySDK::get_singleton()->is_enabled()) {
 		sentry::util::print_debug("error logger is not started because SDK is not initialized");
 		return;
 	}
 	// Add experimental logger to scene tree.
 	sentry::util::print_debug("starting error logger");
 	SceneTree *sml = Object::cast_to<SceneTree>(Engine::get_singleton()->get_main_loop());
 	if (sml && sml->get_root()) {
-		sml->get_root()->add_child(memnew(SentryLogger));
+		sml->get_root()->add_child(memnew(sentry::SentryLogger));
 	} else {
 		ERR_FAIL_MSG("Sentry: Internal error: SceneTree is null.");
 	}
 }
 
 } // unnamed namespace
 
-void initialize_module(ModuleInitializationLevel p_level) {
+void sentry_godot_initialize_module(ModuleInitializationLevel p_level) {
 	if (p_level == MODULE_INITIALIZATION_LEVEL_CORE) {
 	} else if (p_level == godot::MODULE_INITIALIZATION_LEVEL_SERVERS) {
 	} else if (p_level == MODULE_INITIALIZATION_LEVEL_SCENE) {
-		GDREGISTER_CLASS(SentryLoggerLimits);
-		GDREGISTER_CLASS(SentryOptions);
-		GDREGISTER_INTERNAL_CLASS(RuntimeConfig);
-		GDREGISTER_CLASS(SentryConfiguration);
-		GDREGISTER_CLASS(SentryUser);
-		GDREGISTER_CLASS(SentrySDK);
-		GDREGISTER_ABSTRACT_CLASS(SentryEvent);
-		GDREGISTER_INTERNAL_CLASS(DisabledEvent);
-		GDREGISTER_INTERNAL_CLASS(SentryLogger);
+		GDREGISTER_CLASS(sentry::SentryLoggerLimits);
+		GDREGISTER_CLASS(sentry::SentryOptions);
+		GDREGISTER_INTERNAL_CLASS(sentry::RuntimeConfig);
+		GDREGISTER_CLASS(sentry::SentryConfiguration);
+		GDREGISTER_CLASS(sentry::SentryUser);
+		GDREGISTER_CLASS(sentry::SentrySDK);
+		GDREGISTER_ABSTRACT_CLASS(sentry::SentryEvent);
+		GDREGISTER_INTERNAL_CLASS(sentry::DisabledEvent);
+		GDREGISTER_INTERNAL_CLASS(sentry::SentryLogger);
 #ifdef NATIVE_SDK
-		GDREGISTER_INTERNAL_CLASS(NativeEvent);
+		GDREGISTER_INTERNAL_CLASS(sentry::NativeEvent);
 #endif // NATIVE_SDK
+#ifdef COCOA_SDK
+		GDREGISTER_INTERNAL_CLASS(sentry::CocoaEvent);
+#endif // COCOA_SDK
 
-		SentryOptions::create_singleton();
+		sentry::SentryOptions::create_singleton();
 
-		SentrySDK *sentry_singleton = memnew(SentrySDK);
-		Engine::get_singleton()->register_singleton("SentrySDK", SentrySDK::get_singleton());
+		sentry::SentrySDK *sentry_singleton = memnew(sentry::SentrySDK);
+		Engine::get_singleton()->register_singleton("SentrySDK", sentry::SentrySDK::get_singleton());
 
 		callable_mp_static(_init_logger).call_deferred();
 	}
 }
 
-void uninitialize_module(ModuleInitializationLevel p_level) {
+void sentry_godot_uninitialize_module(ModuleInitializationLevel p_level) {
 	if (p_level == MODULE_INITIALIZATION_LEVEL_SCENE) {
-		if (SentrySDK::get_singleton()) {
-			memdelete(SentrySDK::get_singleton());
+		if (sentry::SentrySDK::get_singleton()) {
+			memdelete(sentry::SentrySDK::get_singleton());
 		}
-		SentryOptions::destroy_singleton();
+		sentry::SentryOptions::destroy_singleton();
 	}
 }
 
 extern "C" {
 // Initialization.
-GDExtensionBool GDE_EXPORT gdextension_init(GDExtensionInterfaceGetProcAddress p_get_proc_address, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
+GDExtensionBool GDE_EXPORT sentry_godot_gdextension_init(GDExtensionInterfaceGetProcAddress p_get_proc_address, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
 	godot::GDExtensionBinding::InitObject init_obj(p_get_proc_address, p_library, r_initialization);
 
-	init_obj.register_initializer(initialize_module);
-	init_obj.register_terminator(uninitialize_module);
+	init_obj.register_initializer(sentry_godot_initialize_module);
+	init_obj.register_terminator(sentry_godot_uninitialize_module);
 	init_obj.set_minimum_library_initialization_level(MODULE_INITIALIZATION_LEVEL_SCENE);
 
 	return init_obj.init();

src/runtime_config.cpp

@@ -10,6 +10,8 @@ inline String _ensure_string(const Variant &p_value, const String &p_fallback) {
 
 } // unnamed namespace
 
+namespace sentry {
+
 void RuntimeConfig::set_installation_id(const String &p_id) {
 	ERR_FAIL_COND(p_id.length() == 0);
 
@@ -33,3 +35,5 @@ void RuntimeConfig::load_file(const String &p_conf_path) {
 RuntimeConfig::RuntimeConfig() {
 	conf.instantiate();
 }
+
+}

src/runtime_config.h

@@ -9,6 +9,8 @@
 
 using namespace godot;
 
+namespace sentry {
+
 class RuntimeConfig : public RefCounted {
 	GDCLASS(RuntimeConfig, RefCounted)
 private:
@@ -30,4 +32,6 @@ class RuntimeConfig : public RefCounted {
 	RuntimeConfig();
 };
 
+};
+
 #endif // RUNTIME_CONFIG_H

src/sentry/cocoa/cocoa_event.h

@@ -0,0 +1,58 @@
+#ifndef COCOA_EVENT_H
+#define COCOA_EVENT_H
+
+#include "sentry_event.h"
+
+namespace sentry {
+
+// Event class that is used with the Cocoa SDK.
+class CocoaEvent : public sentry::SentryEvent {
+	GDCLASS(CocoaEvent, SentryEvent);
+
+private:
+	void *cocoa_event;
+
+protected:
+	static void _bind_methods() {}
+
+public:
+    void* get_native_value() const { return cocoa_event; };
+
+	virtual String get_id() const override;
+
+	virtual void set_message(const String &p_message) override;
+	virtual String get_message() const override;
+
+	virtual void set_timestamp(const String &p_timestamp) override;
+	virtual String get_timestamp() const override;
+
+	virtual String get_platform() const override;
+
+	virtual void set_level(sentry::Level p_level) override;
+	virtual sentry::Level get_level() const override;
+
+	virtual void set_logger(const String &p_logger) override;
+	virtual String get_logger() const override;
+
+	virtual void set_release(const String &p_release) override;
+	virtual String get_release() const override;
+
+	virtual void set_dist(const String &p_dist) override;
+	virtual String get_dist() const override;
+
+	virtual void set_environment(const String &p_environment) override;
+	virtual String get_environment() const override;
+
+	virtual void set_tag(const String &p_key, const String &p_value) override;
+	virtual void remove_tag(const String &p_key) override;
+	virtual String get_tag(const String &p_key) override;
+
+	CocoaEvent(void* p_event);
+	CocoaEvent();
+	virtual ~CocoaEvent() override;
+};
+
+
+}
+
+#endif // COCOA_EVENT_H