fix: move to latest SDKs

Author: farfromrefug

.gitignore

@@ -21,3 +21,4 @@ Pods
 *.xcuserdatad
 /plugin/README.md
 pnpm-lock.yaml
+/plugin/platforms/android/sentry.aar

plugin/platforms/android/include.gradle

@@ -7,6 +7,6 @@ android {
     }
 }
 dependencies {
-    def sentryVersion =  project.hasProperty("sentryVersion") ? project.sentryVersion : "4.2.0"
+    def sentryVersion =  project.hasProperty("sentryVersion") ? project.sentryVersion : "5.2.0"
     implementation "io.sentry:sentry-android:$sentryVersion"
 }

plugin/platforms/android/sentry.aar

@@ -1 +1 @@
-pod 'Sentry', :git => 'https://github.com/getsentry/sentry-cocoa.git', :tag => '6.2.0'
+pod 'Sentry', :git => 'https://github.com/getsentry/sentry-cocoa.git', :tag => '7.3.0'

plugin/platforms/ios/Podfile

@@ -0,0 +1,11 @@
+#import <Sentry/Sentry.h>
+
+
+@interface NSSentrySDK: SentrySDK
+
++ (void)captureEnvelope:(SentryEnvelope *)envelope;
+
++ (void)storeEnvelope:(SentryEnvelope *)envelope;
+
+
+@end

plugin/platforms/ios/src/Info.plist

@@ -0,0 +1,5 @@
+#import "NSSentry.h"
+#import <Sentry/Sentry.h>
+
+@implementation NSSentrySDK
+@end

plugin/platforms/ios/src/NSSentry.h

@@ -0,0 +1,4 @@
+module NSSentry {
+    header "NSSentry.h"
+    export *
+}

plugin/platforms/ios/src/NSSentry.m

@@ -35,6 +35,19 @@ export interface NativescriptOptions extends BrowserOptions {
 
     sessionTrackingIntervalMillis?: number;
 
+    /** Enable scope sync from Java to NDK on Android */
+    enableNdkScopeSync?: boolean;
+
+    /** When enabled, all the threads are automatically attached to all logged events on Android */
+    attachThreads?: boolean;
+
+    /**
+     *  When enabled, certain personally identifiable information (PII) is added by active integrations.
+     *
+     * @default false
+     * */
+    sendDefaultPii?: boolean;
+
     /** Should the native nagger alert be shown or not. */
     // enableNativeNagger?: boolean;
     /**
@@ -53,6 +66,11 @@ export interface NativescriptOptions extends BrowserOptions {
         sentry?: boolean;
         xhr?: boolean;
     };
+
+    /** Enable auto performance tracking by default. */
+    enableAutoPerformanceTracking?: boolean;
+
+    flushSendEvent?: boolean;
 }
 
 /** The Sentry Nativescript SDK Backend. */
@@ -65,9 +83,10 @@ export class NativescriptBackend extends BaseBackend<BrowserOptions> {
         this._browserBackend = new BrowserBackend(_options);
 
         if (_options.enableNative !== false) {
-            NSSentry.startWithDsnString(_options.dsn, _options).then(() => {
-                NSSentry.setLogLevel(_options.debug ? 2 : 1);
-            });
+            NSSentry.startWithDsnString(_options.dsn, _options);
+            // .then(() => {
+            //     // NSSentry.setLogLevel(_options.debug ? 2 : 1);
+            // });
         } else {
             // if (__DEV__ && _options.enableNativeNagger) {
             //     Alert.alert(
@@ -89,7 +108,7 @@ export class NativescriptBackend extends BaseBackend<BrowserOptions> {
 
         const transportOptions = {
             ...this._options.transportOptions,
-            dsn: this._options.dsn,
+            dsn: this._options.dsn
         };
 
         if (this._options.transport) {
@@ -136,12 +155,11 @@ export class NativescriptBackend extends BaseBackend<BrowserOptions> {
     }
 }
 
-
 /**
-* Convert js severity level which has critical and log to more widely supported levels.
-* @param level
-* @returns More widely supported Severity level strings
-*/
+ * Convert js severity level which has critical and log to more widely supported levels.
+ * @param level
+ * @returns More widely supported Severity level strings
+ */
 export function _processLevel(level: Severity): Severity {
     if (level === Severity.Critical) {
         return Severity.Fatal;

plugin/platforms/ios/src/module.modulemap

@@ -1,9 +1,7 @@
 import { BaseClient, Scope } from '@sentry/core';
-import { Event, EventHint } from '@sentry/types';
-import { SyncPromise } from '@sentry/utils';
 
 import { NativescriptBackend, NativescriptOptions } from './backend';
-import { SDK_NAME, SDK_VERSION } from './version';
+import { NSSentry } from './nssentry';
 
 /**
  * The Sentry React Native SDK Client.
@@ -21,31 +19,20 @@ export class NativescriptClient extends BaseClient<NativescriptBackend, Nativesc
     }
 
     /**
-     * @inheritDoc
-     */
-    protected _prepareEvent(event: Event, scope?: Scope, hint?: EventHint): SyncPromise<Event | null> {
-        event.platform = event.platform || 'javascript';
-        event.sdk = {
-            ...event.sdk,
-            name: SDK_NAME,
-            packages: [
-                ...((event.sdk && event.sdk.packages) || []),
-                {
-                    name: 'npm:@nativescript-community/sentry',
-                    version: SDK_VERSION
-                }
-            ],
-            version: SDK_VERSION
-        };
-
-        return super._prepareEvent(event, scope, hint) as any;
-    }
+   * If native client is available it will trigger a native crash.
+   * Use this only for testing purposes.
+   */
+  public nativeCrash(): void {
+    this._getBackend().nativeCrash();
+  }
 
-    /**
-     * If native client is available it will trigger a native crash.
-     * Use this only for testing purposes.
-     */
-    public nativeCrash(): void {
-        this._getBackend().nativeCrash();
-    }
-}
+  /**
+   * @inheritDoc
+   */
+  public close(): PromiseLike<boolean> {
+    // As super.close() flushes queued events, we wait for that to finish before closing the native SDK.
+    return super.close().then((result: boolean) => {
+      return NSSentry.closeNativeSdk().then(() => result) as PromiseLike<boolean>;
+    });
+  }
+}

src/backend.ts

@@ -0,0 +1,28 @@
+import { EventProcessor, Integration } from "@sentry/types";
+
+/** Default EventOrigin instrumentation */
+export class EventOrigin implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = "EventOrigin";
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = EventOrigin.id;
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(addGlobalEventProcessor: (e: EventProcessor) => void): void {
+    addGlobalEventProcessor((event) => {
+      event.tags = event.tags ?? {};
+
+      event.tags["event.origin"] = "javascript";
+      event.tags["event.environment"] = "javascript";
+
+      return event;
+    });
+  }
+}

src/client.ts

@@ -22,33 +22,39 @@ export class Release implements Integration {
             if (!self) {
                 return event;
             }
+            const options = getCurrentHub().getClient()?.getOptions();
+            /*
+        __sentry_release and __sentry_dist is set by the user with setRelease and setDist. If this is used then this is the strongest.
+        Otherwise we check for the release and dist in the options passed on init, as this is stronger than the release/dist from the native build.
+      */
+            if (typeof event.extra?.__sentry_release === 'string') {
+                event.release = `${event.extra.__sentry_release}`;
+            } else if (typeof options?.release === 'string') {
+                event.release = options.release;
+            }
 
+            if (typeof event.extra?.__sentry_dist === 'string') {
+                event.dist = `${event.extra.__sentry_dist}`;
+            } else if (typeof options?.dist === 'string') {
+                event.dist = options.dist;
+            }
+
+            if (event.release && event.dist) {
+                return event;
+            }
             try {
-                const release = (await NSSentry.fetchRelease()) as {
+                const release = (await NSSentry.fetchNativeRelease()) as {
                     build: string;
                     id: string;
                     version: string;
                 };
                 if (release) {
-                    if (!event.release) {
-                        event.release = `${release.id}-${release.version}`;
-                    }
-                    if (!event.dist) {
-                        event.dist = `${release.build}`;
-                    }
+                    event.release = `${release.id}@${release.version}+${release.build}`;
+                    event.dist = `${release.build}`;
                 }
             } catch (_Oo) {
                 // Something went wrong, we just continue
             }
-
-            // If __sentry_release or __sentry_dist it should be stronger because the user set it
-            if (event.extra && event.extra.__sentry_release) {
-                event.release = `${event.extra.__sentry_release}`;
-            }
-            if (event.extra && event.extra.__sentry_dist) {
-                event.dist = `${event.extra.__sentry_dist}`;
-            }
-
             return event;
         });
     }

src/integrations/eventorigin.ts

@@ -0,0 +1,58 @@
+import { EventProcessor, Integration, Package } from "@sentry/types";
+import { logger } from "@sentry/utils";
+
+import { SDK_NAME, SDK_VERSION } from "../version";
+import { NSSentry } from '../nssentry';
+
+/** Default SdkInfo instrumentation */
+export class SdkInfo implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = "SdkInfo";
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = SdkInfo.id;
+
+  private _nativeSdkInfo: Package | null = null;
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(addGlobalEventProcessor: (e: EventProcessor) => void): void {
+    addGlobalEventProcessor(async (event) => {
+      // The native SDK info package here is only used on iOS as `beforeSend` is not called on `captureEnvelope`.
+      // this._nativeSdkInfo should be defined a following time so this call won't always be awaited.
+      if (global.isIOS && this._nativeSdkInfo === null) {
+        try {
+          this._nativeSdkInfo = await NSSentry.fetchNativeSdkInfo();
+        } catch (e) {
+          // If this fails, go ahead as usual as we would rather have the event be sent with a package missing.
+          logger.warn(
+            "[SdkInfo] Native SDK Info retrieval failed...something could be wrong with your Sentry installation:"
+          );
+          logger.warn(e);
+        }
+      }
+
+      event.platform = event.platform || "javascript";
+      event.sdk = {
+        ...(event.sdk ?? {}),
+        name: SDK_NAME,
+        packages: [
+          ...((event.sdk && event.sdk.packages) || []),
+          ...((this._nativeSdkInfo && [this._nativeSdkInfo]) || []),
+          {
+            name: "npm:@nativescript-community/sentry",
+            version: SDK_VERSION,
+          },
+        ],
+        version: SDK_VERSION,
+      };
+
+      return event;
+    });
+  }
+}