@sentry/react-native 5.0.0-alpha.1 → 5.0.0-alpha.11

package/android/src/main/java/io/sentry/react/{RNSentryModule.java → RNSentryModuleImpl.java}

@@ -1,62 +1,76 @@
 package io.sentry.react;
 
+import static io.sentry.android.core.internal.util.ScreenshotUtils.takeScreenshot;
+
 import android.app.Activity;
 import android.content.Context;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
+import android.content.res.AssetManager;
 import android.util.SparseIntArray;
 
+import androidx.annotation.Nullable;
 import androidx.core.app.FrameMetricsAggregator;
 
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.module.annotations.ReactModule;
 
+import java.io.BufferedInputStream;
 import java.io.File;
+import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
-import java.io.UnsupportedEncodingException;
+import java.io.InputStream;
 import java.nio.charset.Charset;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
-import io.sentry.SentryEvent;
-import io.sentry.android.core.AnrIntegration;
-import io.sentry.android.core.AppStartState;
-import io.sentry.android.core.NdkIntegration;
-import io.sentry.android.core.SentryAndroid;
 import io.sentry.Breadcrumb;
 import io.sentry.HubAdapter;
+import io.sentry.ILogger;
 import io.sentry.Integration;
 import io.sentry.Sentry;
+import io.sentry.SentryEvent;
 import io.sentry.SentryLevel;
 import io.sentry.UncaughtExceptionHandlerIntegration;
+import io.sentry.android.core.AnrIntegration;
+import io.sentry.android.core.AppStartState;
+import io.sentry.android.core.BuildInfoProvider;
+import io.sentry.android.core.CurrentActivityHolder;
+import io.sentry.android.core.NdkIntegration;
+import io.sentry.android.core.ScreenshotEventProcessor;
+import io.sentry.android.core.SentryAndroid;
+import io.sentry.android.core.AndroidLogger;
 import io.sentry.protocol.SdkVersion;
 import io.sentry.protocol.SentryException;
 import io.sentry.protocol.SentryPackage;
 import io.sentry.protocol.User;
 
-@ReactModule(name = RNSentryModule.NAME)
-public class RNSentryModule extends ReactContextBaseJavaModule {
+public class RNSentryModuleImpl {
 
     public static final String NAME = "RNSentry";
 
-    private static final Logger logger = Logger.getLogger("react-native-sentry");
+    private static final ILogger logger = new AndroidLogger(NAME);
+    private static final BuildInfoProvider buildInfo = new BuildInfoProvider(logger);
+    private static final String modulesPath = "modules.json";
+    private static final Charset UTF_8 = Charset.forName("UTF-8");
 
-    private PackageInfo packageInfo = null;
+    private final ReactApplicationContext reactApplicationContext;
+    private final PackageInfo packageInfo;
     private FrameMetricsAggregator frameMetricsAggregator = null;
-    private boolean androidXAvailable = true;
+    private boolean androidXAvailable;
+    private ScreenshotEventProcessor screenshotEventProcessor;
 
     private static boolean didFetchAppStart;
 
@@ -65,39 +79,36 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
     // 16ms (slower than 60fps) to constitute slow frames.
     private static final int SLOW_FRAME_THRESHOLD = 16;
 
-    public RNSentryModule(ReactApplicationContext reactContext) {
-        super(reactContext);
-        packageInfo = getPackageInfo(reactContext);
+    public RNSentryModuleImpl(ReactApplicationContext reactApplicationContext) {
+        packageInfo = getPackageInfo(reactApplicationContext);
+        this.reactApplicationContext = reactApplicationContext;
     }
 
-    @Override
-    public String getName() {
-        return NAME;
+    private ReactApplicationContext getReactApplicationContext() {
+        return this.reactApplicationContext;
     }
 
-    @Override
-    public Map<String, Object> getConstants() {
-        final Map<String, Object> constants = new HashMap<>();
-        constants.put("nativeClientAvailable", true);
-        constants.put("nativeTransport", true);
-        return constants;
+    private @Nullable
+    Activity getCurrentActivity() {
+        return this.reactApplicationContext.getCurrentActivity();
     }
 
-    @ReactMethod
     public void initNativeSdk(final ReadableMap rnOptions, Promise promise) {
         SentryAndroid.init(this.getReactApplicationContext(), options -> {
             if (rnOptions.hasKey("debug") && rnOptions.getBoolean("debug")) {
                 options.setDebug(true);
-                logger.setLevel(Level.INFO);
             }
             if (rnOptions.hasKey("dsn") && rnOptions.getString("dsn") != null) {
                 String dsn = rnOptions.getString("dsn");
-                logger.info(String.format("Starting with DSN: '%s'", dsn));
+                logger.log(SentryLevel.INFO, String.format("Starting with DSN: '%s'", dsn));
                 options.setDsn(dsn);
             } else {
                 // SentryAndroid needs an empty string fallback for the dsn.
                 options.setDsn("");
             }
+            if (rnOptions.hasKey("sendClientReports")) {
+                options.setSendClientReports(rnOptions.getBoolean("sendClientReports"));
+            }
             if (rnOptions.hasKey("maxBreadcrumbs")) {
                 options.setMaxBreadcrumbs(rnOptions.getInt("maxBreadcrumbs"));
             }
@@ -129,35 +140,18 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
                 options.setAttachStacktrace(rnOptions.getBoolean("attachStacktrace"));
             }
             if (rnOptions.hasKey("attachThreads")) {
-                // JS use top level stacktraces and android attaches Threads which hides them so
+                // JS use top level stacktrace and android attaches Threads which hides them so
                 // by default we hide.
                 options.setAttachThreads(rnOptions.getBoolean("attachThreads"));
             }
+            if (rnOptions.hasKey("attachScreenshot")) {
+                options.setAttachScreenshot(rnOptions.getBoolean("attachScreenshot"));
+            }
             if (rnOptions.hasKey("sendDefaultPii")) {
                 options.setSendDefaultPii(rnOptions.getBoolean("sendDefaultPii"));
             }
-            if (rnOptions.hasKey("enableAutoPerformanceTracking")
-                    && rnOptions.getBoolean("enableAutoPerformanceTracking")) {
-                androidXAvailable = checkAndroidXAvailability();
-
-                if (androidXAvailable) {
-                    frameMetricsAggregator = new FrameMetricsAggregator();
-                    final Activity currentActivity = getCurrentActivity();
-
-                    if (frameMetricsAggregator != null && currentActivity != null) {
-                        try {
-                            frameMetricsAggregator.add(currentActivity);
-                        } catch (Throwable ignored) {
-                            // throws ConcurrentModification when calling addOnFrameMetricsAvailableListener
-                            // this is a best effort since we can't reproduce it
-                            logger.warning("Error adding Activity to frameMetricsAggregator.");
-                        }
-                    }
-                } else {
-                    logger.warning("androidx.core' isn't available as a dependency.");
-                }
-            } else {
-                this.disableNativeFramesTracking();
+            if (rnOptions.hasKey("maxQueueSize")) {
+                options.setMaxQueueSize(rnOptions.getInt("maxQueueSize"));
             }
 
             options.setBeforeSend((event, hint) -> {
@@ -188,19 +182,40 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
                     }
                 }
             }
+            logger.log(SentryLevel.INFO, String.format("Native Integrations '%s'", options.getIntegrations()));
 
-            logger.info(String.format("Native Integrations '%s'", options.getIntegrations().toString()));
+            final CurrentActivityHolder currentActivityHolder = CurrentActivityHolder.getInstance();
+            final Activity currentActivity = getCurrentActivity();
+            if (currentActivity != null) {
+                currentActivityHolder.setActivity(currentActivity);
+            }
         });
 
         promise.resolve(true);
     }
 
-    @ReactMethod
     public void crash() {
         throw new RuntimeException("TEST - Sentry Client Crash (only works in release mode)");
     }
 
-    @ReactMethod
+    public void fetchModules(Promise promise) {
+        final AssetManager assets = this.getReactApplicationContext().getResources().getAssets();
+        try (final InputStream stream =
+                     new BufferedInputStream(assets.open(RNSentryModuleImpl.modulesPath))) {
+            int size = stream.available();
+            byte[] buffer = new byte[size];
+            stream.read(buffer);
+            stream.close();
+            String modulesJson = new String(buffer, RNSentryModuleImpl.UTF_8);
+            promise.resolve(modulesJson);
+        } catch (FileNotFoundException e) {
+            promise.resolve(null);
+        } catch (Throwable e) {
+            logger.log(SentryLevel.WARNING, "Fetching JS Modules failed.");
+            promise.resolve(null);
+        }
+    }
+
     public void fetchNativeRelease(Promise promise) {
         WritableMap release = Arguments.createMap();
         release.putString("id", packageInfo.packageName);
@@ -209,17 +224,16 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
         promise.resolve(release);
     }
 
-    @ReactMethod
     public void fetchNativeAppStart(Promise promise) {
         final AppStartState appStartInstance = AppStartState.getInstance();
         final Date appStartTime = appStartInstance.getAppStartTime();
         final Boolean isColdStart = appStartInstance.isColdStart();
 
         if (appStartTime == null) {
-            logger.warning("App start won't be sent due to missing appStartTime.");
+            logger.log(SentryLevel.WARNING, "App start won't be sent due to missing appStartTime.");
             promise.resolve(null);
         } else if (isColdStart == null) {
-            logger.warning("App start won't be sent due to missing isColdStart.");
+            logger.log(SentryLevel.WARNING, "App start won't be sent due to missing isColdStart.");
             promise.resolve(null);
         } else {
             final double appStartTimestamp = (double) appStartTime.getTime();
@@ -241,7 +255,6 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
     /**
      * Returns frames metrics at the current point in time.
      */
-    @ReactMethod
     public void fetchNativeFrames(Promise promise) {
         if (!isFrameMetricsAggregatorAvailable()) {
             promise.resolve(null);
@@ -285,87 +298,118 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
 
                 promise.resolve(map);
             } catch (Throwable ignored) {
-                logger.warning("Error fetching native frames.");
+                logger.log(SentryLevel.WARNING, "Error fetching native frames.");
                 promise.resolve(null);
             }
         }
     }
 
-    @ReactMethod
-    public void captureEnvelope(String envelope, Promise promise) {
+    public void captureEnvelope(ReadableArray rawBytes, ReadableMap options, Promise promise) {
+        byte[] bytes = new byte[rawBytes.size()];
+        for (int i = 0; i < rawBytes.size(); i++) {
+            bytes[i] = (byte) rawBytes.getInt(i);
+        }
+
         try {
             final String outboxPath = HubAdapter.getInstance().getOptions().getOutboxPath();
 
             if (outboxPath == null) {
-                logger.severe(
+                logger.log(SentryLevel.ERROR,
                         "Error retrieving outboxPath. Envelope will not be sent. Is the Android SDK initialized?");
             } else {
                 File installation = new File(outboxPath, UUID.randomUUID().toString());
                 try (FileOutputStream out = new FileOutputStream(installation)) {
-                    out.write(envelope.getBytes(Charset.forName("UTF-8")));
+                    out.write(bytes);
                 }
             }
         } catch (Throwable ignored) {
-            logger.severe("Error reading envelope");
+            logger.log(SentryLevel.ERROR, "Error while writing envelope to outbox.");
         }
         promise.resolve(true);
     }
 
-    @ReactMethod
-    public void getStringBytesLength(String payload, Promise promise) {
-        try {
-            promise.resolve(payload.getBytes("UTF-8").length);
-        } catch (UnsupportedEncodingException e) {
-            promise.reject(e);
+    public void captureScreenshot(Promise promise) {
+
+        final Activity activity = getCurrentActivity();
+        if (activity == null) {
+            logger.log(SentryLevel.WARNING, "CurrentActivity is null, can't capture screenshot.");
+            promise.resolve(null);
+            return;
         }
+
+        final byte[] raw = takeScreenshot(activity, logger, buildInfo);
+        if (raw == null) {
+            logger.log(SentryLevel.WARNING, "Screenshot is null, screen was not captured.");
+            promise.resolve(null);
+            return;
+        }
+
+        final WritableNativeArray data = new WritableNativeArray();
+        for (final byte b : raw) {
+            data.pushInt(b);
+        }
+        final WritableMap screenshot = new WritableNativeMap();
+        screenshot.putString("contentType", "image/png");
+        screenshot.putArray("data", data);
+        screenshot.putString("filename", "screenshot.png");
+
+        final WritableArray screenshotsArray = new WritableNativeArray();
+        screenshotsArray.pushMap(screenshot);
+        promise.resolve(screenshotsArray);
     }
 
     private static PackageInfo getPackageInfo(Context ctx) {
         try {
             return ctx.getPackageManager().getPackageInfo(ctx.getPackageName(), 0);
         } catch (PackageManager.NameNotFoundException e) {
-            logger.warning("Error getting package info.");
+            logger.log(SentryLevel.WARNING, "Error getting package info.");
             return null;
         }
     }
 
-    @ReactMethod
-    public void setUser(final ReadableMap user, final ReadableMap otherUserKeys) {
+    public void setUser(final ReadableMap userKeys, final ReadableMap userDataKeys) {
         Sentry.configureScope(scope -> {
-            if (user == null && otherUserKeys == null) {
+            if (userKeys == null && userDataKeys == null) {
                 scope.setUser(null);
             } else {
                 User userInstance = new User();
 
-                if (user != null) {
-                    if (user.hasKey("email")) {
-                        userInstance.setEmail(user.getString("email"));
+                if (userKeys != null) {
+                    if (userKeys.hasKey("email")) {
+                        userInstance.setEmail(userKeys.getString("email"));
+                    }
+
+                    if (userKeys.hasKey("id")) {
+                        userInstance.setId(userKeys.getString("id"));
                     }
 
-                    if (user.hasKey("id")) {
-                        userInstance.setId(user.getString("id"));
+                    if (userKeys.hasKey("username")) {
+                        userInstance.setUsername(userKeys.getString("username"));
                     }
 
-                    if (user.hasKey("username")) {
-                        userInstance.setUsername(user.getString("username"));
+                    if (userKeys.hasKey("ip_address")) {
+                        userInstance.setIpAddress(userKeys.getString("ip_address"));
                     }
 
-                    if (user.hasKey("ip_address")) {
-                        userInstance.setIpAddress(user.getString("ip_address"));
+                    if (userKeys.hasKey("segment")) {
+                        userInstance.setSegment(userKeys.getString("segment"));
                     }
                 }
 
-                if (otherUserKeys != null) {
-                    HashMap<String, String> otherUserKeysMap = new HashMap<String, String>();
-                    ReadableMapKeySetIterator it = otherUserKeys.keySetIterator();
+                if (userDataKeys != null) {
+                    HashMap<String, String> userDataMap = new HashMap<>();
+                    ReadableMapKeySetIterator it = userDataKeys.keySetIterator();
                     while (it.hasNextKey()) {
                         String key = it.nextKey();
-                        String value = otherUserKeys.getString(key);
+                        String value = userDataKeys.getString(key);
 
-                        otherUserKeysMap.put(key, value);
+                        // other is ConcurrentHashMap and can't have null values
+                        if (value != null) {
+                            userDataMap.put(key, value);
+                        }
                     }
 
-                    userInstance.setOthers(otherUserKeysMap);
+                    userInstance.setData(userDataMap);
                 }
 
                 scope.setUser(userInstance);
@@ -373,7 +417,6 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
         });
     }
 
-    @ReactMethod
     public void addBreadcrumb(final ReadableMap breadcrumb) {
         Sentry.configureScope(scope -> {
             Breadcrumb breadcrumbInstance = new Breadcrumb();
@@ -398,29 +441,27 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
                     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;
+                    case "info":
                     default:
-                        breadcrumbInstance.setLevel(SentryLevel.ERROR);
+                        breadcrumbInstance.setLevel(SentryLevel.INFO);
                         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);
+                final ReadableMap data = breadcrumb.getMap("data");
+                for (final Map.Entry<String, Object> entry : data.toHashMap().entrySet()) {
+                    final Object value = entry.getValue();
+                    // data is ConcurrentHashMap and can't have null values
+                    if (value != null) {
+                        breadcrumbInstance.setData(entry.getKey(), entry.getValue());
+                    }
                 }
             }
 
@@ -428,21 +469,18 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
         });
     }
 
-    @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 setContext(final String key, final ReadableMap context) {
         if (key == null || context == null) {
             return;
@@ -454,14 +492,12 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
         });
     }
 
-    @ReactMethod
     public void setTag(String key, String value) {
         Sentry.configureScope(scope -> {
             scope.setTag(key, value);
         });
     }
 
-    @ReactMethod
     public void closeNativeSdk(Promise promise) {
         Sentry.close();
 
@@ -470,7 +506,31 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
         promise.resolve(true);
     }
 
-    @ReactMethod
+    public void enableNativeFramesTracking() {
+        androidXAvailable = checkAndroidXAvailability();
+
+        if (androidXAvailable) {
+            frameMetricsAggregator = new FrameMetricsAggregator();
+            final Activity currentActivity = getCurrentActivity();
+
+            if (frameMetricsAggregator != null && currentActivity != null) {
+                try {
+                    frameMetricsAggregator.add(currentActivity);
+
+                    logger.log(SentryLevel.INFO, "FrameMetricsAggregator installed.");
+                } catch (Throwable ignored) {
+                    // throws ConcurrentModification when calling addOnFrameMetricsAvailableListener
+                    // this is a best effort since we can't reproduce it
+                    logger.log(SentryLevel.ERROR, "Error adding Activity to frameMetricsAggregator.");
+                }
+            } else {
+                logger.log(SentryLevel.INFO, "currentActivity isn't available.");
+            }
+        } else {
+            logger.log(SentryLevel.WARNING, "androidx.core' isn't available as a dependency.");
+        }
+    }
+
     public void disableNativeFramesTracking() {
         if (isFrameMetricsAggregatorAvailable()) {
             frameMetricsAggregator.stop();
@@ -485,10 +545,10 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
                 // If the event is from capacitor js, it gets set there and we do not handle it
                 // here.
                 case "sentry.native":
-                    setEventEnvironmentTag(event, "android", "native");
+                    setEventEnvironmentTag(event, "native");
                     break;
                 case "sentry.java.android":
-                    setEventEnvironmentTag(event, "android", "java");
+                    setEventEnvironmentTag(event, "java");
                     break;
                 default:
                     break;
@@ -496,8 +556,8 @@ public class RNSentryModule extends ReactContextBaseJavaModule {
         }
     }
 
-    private void setEventEnvironmentTag(SentryEvent event, String origin, String environment) {
-        event.setTag("event.origin", origin);
+    private void setEventEnvironmentTag(SentryEvent event, String environment) {
+        event.setTag("event.origin", "android");
         event.setTag("event.environment", environment);
     }
 

package/android/src/main/java/io/sentry/react/RNSentryPackage.java

@@ -1,30 +1,46 @@
 package io.sentry.react;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
+import androidx.annotation.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
 
-import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.uimanager.ViewManager;
-import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.TurboReactPackage;
 
-public class RNSentryPackage implements ReactPackage {
-    public RNSentryPackage() {
-    }
+public class RNSentryPackage extends TurboReactPackage {
 
-    @Override
-    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
-        return Arrays.<NativeModule>asList(new RNSentryModule(reactContext));
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    if (name.equals(RNSentryModuleImpl.NAME)) {
+      return new RNSentryModule(reactContext);
+    } else {
+      return null;
     }
+  }
 
-    public List<Class<? extends JavaScriptModule>> createJSModules() {
-        return Collections.emptyList();
-    }
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+      boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
+      moduleInfos.put(
+          RNSentryModuleImpl.NAME,
+          new ReactModuleInfo(
+              RNSentryModuleImpl.NAME,
+              RNSentryModuleImpl.NAME,
+              false, // canOverrideExistingModule
+              false, // needsEagerInit
+              true, // hasConstants
+              false, // isCxxModule
+              isTurboModule // isTurboModule
+      ));
+      return moduleInfos;
+    };
+  }
 
-    @Override
-    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-        return Collections.emptyList();
-    }
 }