Add SentrySerialized to ReactNativeWritable convertor, load device context from sentry-java scope

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Features
 
 - Use `android.namespace` for AGP 8 and RN 0.73 ([#3133](https://github.com/getsentry/sentry-react-native/pull/3133))
+- Load Android device context before `beforeSend` callback ([#3170](https://github.com/getsentry/sentry-react-native/pull/3170))
 
 ### Dependencies
 

android/src/main/java/io/sentry/react/MapConverter.java

@@ -0,0 +1,95 @@
+package io.sentry.react;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+import io.sentry.ILogger;
+import io.sentry.SentryLevel;
+import io.sentry.android.core.AndroidLogger;
+
+public class MapConverter {
+    public static final String NAME = "RNSentry.MapConverter";
+
+    private static final ILogger logger = new AndroidLogger(NAME);
+
+    public static Object convertToWritable(@Nullable Object serialized) {
+        if (serialized instanceof ArrayList) {
+            WritableArray writable = Arguments.createArray();
+            for (Object item : (ArrayList<?>) serialized) {
+                addValueToWritableArray(writable, convertToWritable(item));
+            }
+            return writable;
+        } else if (serialized instanceof Map) {
+            WritableMap writable = Arguments.createMap();
+            for (Map.Entry<?, ?> entry : ((Map<?, ?>) serialized).entrySet()) {
+                Object key = entry.getKey();
+                Object value = entry.getValue();
+
+                if (key instanceof String) {
+                    addValueToWritableMap(writable, (String) key, convertToWritable(value));
+                } else {
+                    logger.log(SentryLevel.ERROR, "Only String keys are supported in Map.", key);
+                }
+            }
+            return writable;
+        } else if (serialized instanceof Number
+            || serialized instanceof Boolean
+            || serialized == null
+            || serialized instanceof String) {
+            return serialized;
+        } else {
+            logger.log(SentryLevel.ERROR, "Supplied serialized value could not be converted.", serialized);
+            return null;
+        }
+    }
+
+    private static void addValueToWritableArray(WritableArray writableArray, Object value) {
+        if (value == null) {
+            writableArray.pushNull();
+        } else if (value instanceof Boolean) {
+            writableArray.pushBoolean((Boolean) value);
+        } else if (value instanceof Double) {
+            writableArray.pushDouble((Double) value);
+        } else if (value instanceof Integer) {
+            writableArray.pushInt((Integer) value);
+        } else if (value instanceof String) {
+            writableArray.pushString((String) value);
+        } else if (value instanceof ReadableMap) {
+            writableArray.pushMap((ReadableMap) value);
+        } else if (value instanceof ReadableArray) {
+            writableArray.pushArray((ReadableArray) value);
+        } else {
+            logger.log(SentryLevel.ERROR,
+                    "Could not convert object: " + value);
+        }
+    }
+
+    private static void addValueToWritableMap(WritableMap writableMap, String key, Object value) {
+        if (value == null) {
+            writableMap.putNull(key);
+        } else if (value instanceof Boolean) {
+            writableMap.putBoolean(key, (Boolean) value);
+        } else if (value instanceof Double) {
+            writableMap.putDouble(key, (Double) value);
+        } else if (value instanceof Integer) {
+            writableMap.putInt(key, (Integer) value);
+        } else if (value instanceof String) {
+            writableMap.putString(key, (String) value);
+        } else if (value instanceof ReadableArray) {
+            writableMap.putArray(key, (ReadableArray) value);
+        } else if (value instanceof ReadableMap) {
+            writableMap.putMap(key, (ReadableMap) value);
+        } else {
+            logger.log(SentryLevel.ERROR,
+                "Could not convert object" + value);
+        }
+    }
+}

android/src/main/java/io/sentry/react/RNSentryModuleImpl.java

@@ -24,10 +24,14 @@
 import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
+import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.Charset;
 import java.util.HashMap;
@@ -39,12 +43,18 @@
 
 import io.sentry.Breadcrumb;
 import io.sentry.DateUtils;
+import io.sentry.EnvelopeReader;
+import io.sentry.Hub;
 import io.sentry.HubAdapter;
+import io.sentry.IEnvelopeReader;
 import io.sentry.ILogger;
 import io.sentry.ISerializer;
 import io.sentry.Integration;
+import io.sentry.InternalSentrySdk;
+import io.sentry.Scope;
 import io.sentry.Sentry;
 import io.sentry.SentryDate;
+import io.sentry.SentryEnvelope;
 import io.sentry.SentryEvent;
 import io.sentry.SentryLevel;
 import io.sentry.UncaughtExceptionHandlerIntegration;
@@ -334,20 +344,19 @@ public void captureEnvelope(ReadableArray rawBytes, ReadableMap options, Promise
             bytes[i] = (byte) rawBytes.getInt(i);
         }
 
-        try {
-            final String outboxPath = HubAdapter.getInstance().getOptions().getOutboxPath();
-
-            if (outboxPath == null) {
-                logger.log(SentryLevel.ERROR,
-                        "Error retrieving outboxPath. Envelope will not be sent. Is the Android SDK initialized?");
+        final HubAdapter hubAdapter = HubAdapter.getInstance();
+        IEnvelopeReader envelopeReader = hubAdapter.getOptions().getEnvelopeReader();
+        try (final InputStream byteStream = new ByteArrayInputStream(bytes)) {
+            final SentryEnvelope sentryEnvelope = envelopeReader.read(byteStream);
+            if (sentryEnvelope != null) {
+                hubAdapter.captureEnvelope(sentryEnvelope);
             } else {
-                File installation = new File(outboxPath, UUID.randomUUID().toString());
-                try (FileOutputStream out = new FileOutputStream(installation)) {
-                    out.write(bytes);
-                }
+                logger.log(SentryLevel.ERROR, "Sentry Envelope Reader returned null after reading envelopes bytes");
+                promise.resolve(false);
             }
-        } catch (Throwable ignored) {
-            logger.log(SentryLevel.ERROR, "Error while writing envelope to outbox.");
+        } catch (IOException e) {
+            logger.log(SentryLevel.ERROR, "Error while reading envelope bytes");
+            promise.resolve(false);
         }
         promise.resolve(true);
     }
@@ -616,6 +625,28 @@ public void disableNativeFramesTracking() {
         }
     }
 
+    public void fetchNativeDeviceContexts(Promise promise) {
+        // Temp work around until sorted out this API in sentry-java.
+        // TODO: If the callback isn't executed the promise wouldn't be resolved.
+        HubAdapter.getInstance().withScope((@NotNull final Scope scope) -> {
+            final Map<String, Object> serialized = InternalSentrySdk.serializeScope(scope);
+            final Object deviceContext = MapConverter.convertToWritable(serialized);
+            promise.resolve(deviceContext);
+        });
+    }
+
+    public void fetchNativeSdkInfo(Promise promise) {
+        @Nullable final SdkVersion sdkVersion = HubAdapter.getInstance().getOptions().getSdkVersion();
+        if (sdkVersion == null) {
+            promise.resolve(null);
+        } else {
+            final WritableMap sdkInfo = new WritableNativeMap();
+            sdkInfo.putString("name", sdkVersion.getName());
+            sdkInfo.putString("version", sdkVersion.getVersion());
+            promise.resolve(sdkInfo);
+        }
+    }
+
     private void setEventOriginTag(SentryEvent event) {
         SdkVersion sdk = event.getSdk();
         if (sdk != null) {

android/src/newarch/java/io/sentry/react/RNSentryModule.java

@@ -114,11 +114,11 @@ public void disableNativeFramesTracking() {
 
     @Override
     public void fetchNativeDeviceContexts(Promise promise) {
-        // Not used on android
+        this.impl.fetchNativeDeviceContexts(promise);
     }
 
     @Override
     public void fetchNativeSdkInfo(Promise promise) {
-        // Not used on android
+        this.impl.fetchNativeSdkInfo(promise);
     }
 }

android/src/oldarch/java/io/sentry/react/RNSentryModule.java

@@ -114,11 +114,11 @@ public void disableNativeFramesTracking() {
 
     @ReactMethod
     public void fetchNativeDeviceContexts(Promise promise) {
-        // Not used on android
+        this.impl.fetchNativeDeviceContexts(promise);
     }
 
     @ReactMethod
     public void fetchNativeSdkInfo(Promise promise) {
-        // Not used on android
+        this.impl.fetchNativeSdkInfo(promise);
     }
 }

src/js/NativeRNSentry.ts

@@ -19,7 +19,7 @@ export interface Spec extends TurboModule {
   closeNativeSdk(): Promise<void>;
   disableNativeFramesTracking(): void;
   fetchNativeRelease(): Promise<NativeReleaseResponse>;
-  fetchNativeSdkInfo(): Promise<Package>;
+  fetchNativeSdkInfo(): Promise<Package | null>;
   fetchNativeDeviceContexts(): Promise<NativeDeviceContextsResponse>;
   fetchNativeAppStart(): Promise<NativeAppStartResponse | null>;
   fetchNativeFrames(): Promise<NativeFramesResponse | null>;

src/js/wrapper.ts

@@ -49,7 +49,6 @@ interface SentryNativeWrapper {
   _processLevel(level: SeverityLevel): SeverityLevel;
   _serializeObject(data: { [key: string]: unknown }): { [key: string]: string };
   _isModuleLoaded(module: Spec | undefined): module is Spec;
-  _getBreadcrumbs(event: Event): Breadcrumb[] | undefined;
 
   isNativeAvailable(): boolean;
 
@@ -252,11 +251,6 @@ export const NATIVE: SentryNativeWrapper = {
       throw this._NativeClientError;
     }
 
-    if (this.platform !== 'ios') {
-      // Only ios uses deviceContexts, return an empty object.
-      return {};
-    }
-
     return RNSentry.fetchNativeDeviceContexts();
   },
 
@@ -514,7 +508,6 @@ export const NATIVE: SentryNativeWrapper = {
           // @ts-ignore Android still uses the old message object, without this the serialization of events will break.
           event.message = { message: event.message };
         }
-        event.breadcrumbs = this._getBreadcrumbs(event);
       }
 
       return [itemHeader, event];
@@ -582,27 +575,6 @@ export const NATIVE: SentryNativeWrapper = {
 
   _NativeClientError: new SentryError("Native Client is not available, can't start on native."),
 
-  /**
-   * Get breadcrumbs (removes breadcrumbs from handled exceptions on Android)
-   *
-   * We do this to avoid duplicate breadcrumbs on Android as sentry-android applies the breadcrumbs
-   * from the native scope onto every envelope sent through it. This scope will contain the breadcrumbs
-   * sent through the scope sync feature. This causes duplicate breadcrumbs.
-   * We then remove the breadcrumbs in all cases but if it is handled == false,
-   * this is a signal that the app would crash and android would lose the breadcrumbs by the time the app is restarted to read
-   * the envelope.
-   */
-  _getBreadcrumbs(event: Event): Breadcrumb[] | undefined {
-    let breadcrumbs: Breadcrumb[] | undefined = event.breadcrumbs;
-
-    const hardCrashed = isHardCrash(event);
-    if (NATIVE.platform === 'android' && event.breadcrumbs && !hardCrashed) {
-      breadcrumbs = [];
-    }
-
-    return breadcrumbs;
-  },
-
   enableNative: true,
   nativeIsReady: false,
   platform: Platform.OS,