feat: basic object merging

src/sentry_scope.c

@@ -1,4 +1,5 @@
 #include "sentry_scope.h"
+#include "sentry.h"
 #include "sentry_backend.h"
 #include "sentry_core.h"
 #include "sentry_database.h"
@@ -7,6 +8,7 @@
 #include "sentry_string.h"
 #include "sentry_symbolizer.h"
 #include "sentry_sync.h"
+#include "sentry_value.h"
 
 #include <stdlib.h>
 
@@ -293,9 +295,10 @@ sentry__scope_apply_to_event(const sentry_scope_t *scope,
     PLACE_STRING("transaction", scope->transaction);
     PLACE_VALUE("sdk", scope->client_sdk);
 
-    // TODO: these should merge
-    PLACE_CLONED_VALUE("tags", scope->tags);
-    PLACE_CLONED_VALUE("extra", scope->extra);
+    sentry_value_t event_tags = sentry_value_get_by_key(event, "tags");
+    sentry__value_merge_objects(event_tags, scope->tags);
+    sentry_value_t event_extra = sentry_value_get_by_key(event, "extra");
+    sentry__value_merge_objects(event_extra, scope->extra);
 
 #ifdef SENTRY_PERFORMANCE_MONITORING
     // TODO: better, more thorough deep merging

src/sentry_value.c

@@ -1,3 +1,4 @@
+#include "sentry.h"
 #include "sentry_boot.h"
 
 #include <assert.h>
@@ -806,6 +807,38 @@ sentry_value_is_null(sentry_value_t value)
     return value._bits == CONST_NULL;
 }
 
+int
+sentry__value_merge_objects(sentry_value_t dst, sentry_value_t src)
+{
+    if (sentry_value_get_type(dst) != SENTRY_VALUE_TYPE_OBJECT
+        || sentry_value_get_type(src) != SENTRY_VALUE_TYPE_OBJECT
+        || sentry_value_is_frozen(dst)) {
+        return 1;
+    }
+    thing_t *thing = value_as_thing(src);
+    if (!thing) {
+        return 1;
+    }
+    obj_t *obj = thing->payload._ptr;
+    for (size_t i = 0; i < obj->len; i++) {
+        char *key = obj->pairs[i].k;
+        sentry_value_t src_val = obj->pairs[i].v;
+        sentry_value_t dst_val = sentry_value_get_by_key(dst, key);
+        if (sentry_value_get_type(dst_val) == SENTRY_VALUE_TYPE_OBJECT
+            && sentry_value_get_type(src_val) == SENTRY_VALUE_TYPE_OBJECT) {
+            if (sentry__value_merge_objects(dst_val, src_val)) {
+                return 1;
+            }
+        } else {
+            if (sentry_value_set_by_key(dst, key, src_val)) {
+                return 1;
+            }
+            sentry_value_incref(src_val);
+        }
+    }
+    return 0;
+}
+
 void
 sentry__jsonwriter_write_value(sentry_jsonwriter_t *jw, sentry_value_t value)
 {

src/sentry_value.h

@@ -1,6 +1,7 @@
 #ifndef SENTRY_VALUE_H_INCLUDED
 #define SENTRY_VALUE_H_INCLUDED
 
+#include "sentry.h"
 #include "sentry_boot.h"
 
 /**
@@ -96,6 +97,18 @@ sentry_value_t sentry__value_clone(sentry_value_t value);
 int sentry__value_append_bounded(
     sentry_value_t value, sentry_value_t v, size_t max);
 
+/**
+ * Deep-merges object src into dst.
+ *
+ * For each key-value pair in the src object the same key in the dst object
+ * will be set to the value from src.  If both the dst value and the src value
+ * are objects themselves they are stepped into recursively instead of
+ * overriding the entire dst object.
+ *
+ * Returns 0 on success.
+ */
+int sentry__value_merge_objects(sentry_value_t dst, sentry_value_t src);
+
 /**
  * Parse the given JSON string into a new Value.
  */

tests/unit/test_value.c

@@ -229,6 +229,56 @@ SENTRY_TEST(value_object)
     sentry_value_decref(val);
 }
 
+SENTRY_TEST(value_object_merge)
+{
+    sentry_value_t dst = sentry_value_new_object();
+    sentry_value_set_by_key(dst, "a", sentry_value_new_int32(1));
+    sentry_value_set_by_key(dst, "b", sentry_value_new_int32(2));
+
+    sentry_value_t src = sentry_value_new_object();
+    sentry_value_set_by_key(src, "b", sentry_value_new_int32(20));
+    sentry_value_set_by_key(src, "c", sentry_value_new_int32(30));
+
+    int rv = sentry__value_merge_objects(dst, src);
+    TEST_CHECK_INT_EQUAL(rv, 0);
+
+    sentry_value_t a = sentry_value_get_by_key(dst, "a");
+    sentry_value_t b = sentry_value_get_by_key(dst, "b");
+    sentry_value_t c = sentry_value_get_by_key(dst, "c");
+    TEST_CHECK_INT_EQUAL(sentry_value_as_int32(a), 1);
+    TEST_CHECK_INT_EQUAL(sentry_value_as_int32(b), 20);
+    TEST_CHECK_INT_EQUAL(sentry_value_as_int32(c), 30);
+}
+
+SENTRY_TEST(value_object_merge_nested)
+{
+    sentry_value_t dst = sentry_value_new_object();
+    sentry_value_set_by_key(dst, "a", sentry_value_new_int32(1));
+    sentry_value_t dst_nested = sentry_value_new_object();
+    sentry_value_set_by_key(dst_nested, "ba", sentry_value_new_int32(1));
+    sentry_value_set_by_key(dst_nested, "bb", sentry_value_new_int32(2));
+    sentry_value_set_by_key(dst, "b", dst_nested);
+
+    sentry_value_t src = sentry_value_new_object();
+    sentry_value_t src_nested = sentry_value_new_object();
+    sentry_value_set_by_key(src_nested, "bb", sentry_value_new_int32(20));
+    sentry_value_set_by_key(src_nested, "bc", sentry_value_new_int32(30));
+    sentry_value_set_by_key(src, "b", src_nested);
+
+    int rv = sentry__value_merge_objects(dst, src);
+    TEST_CHECK_INT_EQUAL(rv, 0);
+
+    sentry_value_t a = sentry_value_get_by_key(dst, "a");
+    sentry_value_t nested = sentry_value_get_by_key(dst, "b");
+    sentry_value_t ba = sentry_value_get_by_key(nested, "ba");
+    sentry_value_t bb = sentry_value_get_by_key(nested, "bb");
+    sentry_value_t bc = sentry_value_get_by_key(nested, "bc");
+    TEST_CHECK_INT_EQUAL(sentry_value_as_int32(a), 1);
+    TEST_CHECK_INT_EQUAL(sentry_value_as_int32(ba), 1);
+    TEST_CHECK_INT_EQUAL(sentry_value_as_int32(bb), 20);
+    TEST_CHECK_INT_EQUAL(sentry_value_as_int32(bc), 30);
+}
+
 SENTRY_TEST(value_freezing)
 {
     sentry_value_t val = sentry_value_new_list();

tests/unit/tests.inc

@@ -79,6 +79,8 @@ XX(value_json_surrogates)
 XX(value_list)
 XX(value_null)
 XX(value_object)
+XX(value_object_merge)
+XX(value_object_merge_nested)
 XX(value_string)
 XX(value_unicode)
 XX(value_wrong_type)