feat: Sync RN scope to native

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Extend Scope methods to set native scope too. #902
+
 ## 1.4.2
 
 - Bump android 2.1.4 #891
@@ -138,7 +140,7 @@ New way to import and init the SDK:
 import * as Sentry from "@sentry/react-native";
 
 Sentry.init({
-  dsn: "DSN",
+  dsn: "DSN"
 });
 ```
 
@@ -374,7 +376,7 @@ To activate it set:
 
 ```js
 Sentry.config("___DSN___", {
-  deactivateStacktraceMerging: false,
+  deactivateStacktraceMerging: false
 });
 ```
 

android/src/main/java/io/sentry/RNSentryModule.java

@@ -10,13 +10,16 @@
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.module.annotations.ReactModule;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.UnsupportedEncodingException;
 import java.nio.charset.Charset;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
@@ -29,11 +32,14 @@
 import io.sentry.android.core.NdkIntegration;
 import io.sentry.android.core.SentryAndroid;
 import io.sentry.core.Sentry;
+import io.sentry.core.Breadcrumb;
 import io.sentry.core.Integration;
+import io.sentry.core.SentryLevel;
 import io.sentry.core.SentryOptions;
 import io.sentry.core.UncaughtExceptionHandlerIntegration;
 import io.sentry.core.protocol.SdkVersion;
 import io.sentry.core.protocol.SentryException;
+import io.sentry.core.protocol.User;
 
 @ReactModule(name = RNSentryModule.NAME)
 public class RNSentryModule extends ReactContextBaseJavaModule {
@@ -213,4 +219,124 @@ private Level logLevel(int level) {
                 return Level.OFF;
         }
     }
+
+    @ReactMethod
+    public void setUser(final ReadableMap user, final ReadableMap otherUserKeys) {
+        Sentry.configureScope(scope -> {
+            if (user == null && otherUserKeys == null) {
+                scope.setUser(null);
+            } else {
+                User userInstance = new User();
+
+                if (user != null) {
+                    if (user.hasKey("email")) {
+                        userInstance.setEmail(user.getString("email"));
+                    }
+
+                    if (user.hasKey("id")) {
+                        userInstance.setId(user.getString("id"));
+                    }
+
+                    if (user.hasKey("username")) {
+                        userInstance.setUsername(user.getString("username"));
+                    }
+
+                    if (user.hasKey("ip_address")) {
+                        userInstance.setIpAddress(user.getString("ip_address"));
+                    }
+                }
+
+                if (otherUserKeys != null) {
+                    HashMap<String, String> otherUserKeysMap = new HashMap<String, String>();
+                    ReadableMapKeySetIterator it = otherUserKeys.keySetIterator();
+                    while (it.hasNextKey()) {
+                        String key = it.nextKey();
+                        String value = otherUserKeys.getString(key);
+
+                        otherUserKeysMap.put(key, value);
+                    }
+
+                    userInstance.setOthers(otherUserKeysMap);
+                }
+
+                scope.setUser(userInstance);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void addBreadcrumb(final ReadableMap breadcrumb) {
+        Sentry.configureScope(scope -> {
+            Breadcrumb breadcrumbInstance = new Breadcrumb();
+
+            if (breadcrumb.hasKey("message")) {
+                breadcrumbInstance.setMessage(breadcrumb.getString("message"));
+            }
+
+            if (breadcrumb.hasKey("type")) {
+                breadcrumbInstance.setType(breadcrumb.getString("type"));
+            }
+
+            if (breadcrumb.hasKey("category")) {
+                breadcrumbInstance.setCategory(breadcrumb.getString("category"));
+            }
+
+            if (breadcrumb.hasKey("level")) {
+                switch (breadcrumb.getString("level")) {
+                    case "fatal":
+                        breadcrumbInstance.setLevel(SentryLevel.FATAL);
+                        break;
+                    case "warning":
+                        breadcrumbInstance.setLevel(SentryLevel.WARNING);
+                        break;
+                    case "info":
+                        breadcrumbInstance.setLevel(SentryLevel.INFO);
+                        break;
+                    case "debug":
+                        breadcrumbInstance.setLevel(SentryLevel.DEBUG);
+                        break;
+                    case "error":
+                        breadcrumbInstance.setLevel(SentryLevel.ERROR);
+                        break;
+                    default:
+                        breadcrumbInstance.setLevel(SentryLevel.ERROR);
+                        break;
+                }
+            }
+
+            if (breadcrumb.hasKey("data")) {
+                ReadableMap data = breadcrumb.getMap("data");
+                ReadableMapKeySetIterator it = data.keySetIterator();
+                while (it.hasNextKey()) {
+                    String key = it.nextKey();
+                    String value = data.getString(key);
+
+                    breadcrumbInstance.setData(key, value);
+                }
+            }
+
+            scope.addBreadcrumb(breadcrumbInstance);
+        });
+    }
+
+    @ReactMethod
+    public void clearBreadcrumbs() {
+        Sentry.configureScope(scope -> {
+            scope.clearBreadcrumbs();
+        });
+    }
+
+    @ReactMethod
+    public void setExtra(String key, String extra) {
+        Sentry.configureScope(scope -> {
+            scope.setExtra(key, extra);
+        });
+    }
+
+    @ReactMethod
+    public void setTag(String key, String value) {
+        Sentry.configureScope(scope -> {
+            scope.setTag(key, value);
+        });
+    }
 }

ios/RNSentry.m

@@ -132,6 +132,96 @@ + (BOOL)requiresMainQueueSetup {
     });
 }
 
+RCT_EXPORT_METHOD(setUser:(NSDictionary *)user
+                  otherUserKeys:(NSDictionary *)otherUserKeys
+)
+{
+    [SentrySDK configureScope:^(SentryScope * _Nonnull scope) {
+        if (nil == user && nil == otherUserKeys) {
+            [scope setUser:nil];
+        } else {
+            SentryUser* userInstance = [[SentryUser alloc] init];
+
+            if (nil != user) {
+                [userInstance setUserId:user[@"id"]];
+                [userInstance setEmail:user[@"email"]];
+                [userInstance setUsername:user[@"username"]];
+            }
+
+            if (nil != otherUserKeys) {
+                [userInstance setData:otherUserKeys];
+            }
+
+            [scope setUser:userInstance];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(addBreadcrumb:(NSDictionary *)breadcrumb)
+{
+    [SentrySDK configureScope:^(SentryScope * _Nonnull scope) {
+        SentryBreadcrumb* breadcrumbInstance = [[SentryBreadcrumb alloc] init];
+
+        NSString * levelString = breadcrumb[@"level"];
+        SentryLevel sentryLevel;
+        if ([levelString isEqualToString:@"fatal"]) {
+            sentryLevel = kSentryLevelFatal;
+        } else if ([levelString isEqualToString:@"warning"]) {
+            sentryLevel = kSentryLevelWarning;
+        } else if ([levelString isEqualToString:@"info"]) {
+            sentryLevel = kSentryLevelInfo;
+        } else if ([levelString isEqualToString:@"debug"]) {
+            sentryLevel = kSentryLevelDebug;
+        } else {
+            sentryLevel = kSentryLevelError;
+        }
+        [breadcrumbInstance setLevel:sentryLevel];
+
+        [breadcrumbInstance setCategory:breadcrumb[@"category"]];
+
+        [breadcrumbInstance setType:breadcrumb[@"type"]];
+
+        [breadcrumbInstance setMessage:breadcrumb[@"message"]];
+
+        [breadcrumbInstance setData:breadcrumb[@"data"]];
+
+        [scope addBreadcrumb:breadcrumbInstance];
+    }];
+}
+
+RCT_EXPORT_METHOD(clearBreadcrumbs) {
+    [SentrySDK configureScope:^(SentryScope * _Nonnull scope) {
+        [scope clearBreadcrumbs];
+    }];
+}
+
+RCT_EXPORT_METHOD(setExtra:(NSString *)key
+                  extra:(NSString *)extra
+)
+{
+    [SentrySDK configureScope:^(SentryScope * _Nonnull scope) {
+        [scope setExtraValue:extra forKey:key];
+    }];
+}
+
+RCT_EXPORT_METHOD(setContext:(NSString *)key
+                  context:(NSDictionary *)context
+)
+{
+    [SentrySDK configureScope:^(SentryScope * _Nonnull scope) {
+        [scope setContextValue:context forKey:key];
+    }];
+}
+
+RCT_EXPORT_METHOD(setTag:(NSString *)key
+                  value:(NSString *)value
+)
+{
+    [SentrySDK configureScope:^(SentryScope * _Nonnull scope) {
+        [scope setTagValue:value forKey:key];
+    }];
+}
+
 RCT_EXPORT_METHOD(crash)
 {
     [SentrySDK crash];

package.json

@@ -36,6 +36,7 @@
   "dependencies": {
     "@sentry/browser": "^5.15.5",
     "@sentry/core": "^5.15.5",
+    "@sentry/hub": "^5.15.5",
     "@sentry/integrations": "^5.15.5",
     "@sentry/types": "^5.15.5",
     "@sentry/utils": "^5.15.5",