feat: captureScreenshot support

Author: farfromrefug

src/client.ts

@@ -13,6 +13,7 @@ import { NativeTransport } from './transports/native';
 import { createUserFeedbackEnvelope, items } from './utils/envelope';
 import { mergeOutcomes } from './utils/outcome';
 import { NATIVE } from './wrapper';
+import { Screenshot } from './integrations/screenshot';
 
 
 /**
@@ -59,12 +60,13 @@ export class NativescriptClient extends BaseClient<NativescriptClientOptions> {
     /**
    * @inheritDoc
    */
-    public eventFromException(_exception: unknown, _hint?: EventHint): PromiseLike<Event> {
+    public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {
         // N put stackTrace in "stackTrace" instead of "stacktrace"
-        if (_exception['stackTrace']) {
-            _exception['stacktrace'] = _exception['stackTrace'];
+        if (exception['stackTrace']) {
+            exception['stacktrace'] = exception['stackTrace'];
         }
-        return this._browserClient.eventFromException(_exception, _hint);
+        Screenshot.attachScreenshotToEventHint(hint, this._options);
+        return this._browserClient.eventFromException(exception, hint);
     }
 
     /**

src/integrations/nativescripterrorhandlers.ts

@@ -1,12 +1,13 @@
 import { getCurrentHub } from '@sentry/core';
 import { eventFromUnknownInput } from '@sentry/browser/esm/eventbuilder';
-import { Integration, SeverityLevel } from '@sentry/types';
+import { EventHint, Integration, SeverityLevel } from '@sentry/types';
 import { NATIVE } from '../wrapper';
 import { addExceptionMechanism, getGlobalObject, logger } from '@sentry/utils';
 
 import { NativescriptClient } from '../client';
 
 import {Application, Trace} from '@nativescript/core';
+import { Screenshot } from './screenshot';
 
 /** NativescriptErrorHandlers Options */
 export interface NativescriptErrorHandlersOptions {
@@ -123,28 +124,34 @@ export class NativescriptErrorHandlers implements Integration {
 
                 return;
             }
+
+
+            // We override client.eventFromException because it is async function
+            // while not needed and we want to be sync
             if (error['stackTrace']) {
                 error['stacktrace'] = error['stackTrace'];
             }
-            // const syntheticException = (hint && hint.syntheticException) || undefined;
-            const event = eventFromUnknownInput(client.getOptions().stackParser, error, undefined, true);
+            let hint: EventHint = {
+                originalException: error
+            };
+            const syntheticException = (hint && hint.syntheticException) || undefined;
+            hint = Screenshot.attachScreenshotToEventHint(hint, client.getOptions());
+            const event = eventFromUnknownInput(client.getOptions().stackParser, error, syntheticException, client.getOptions().attachStacktrace);
             addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }
             event.level = 'error';
-            // const event = await client.eventFromException(error, {
-            //     originalException: error
-            // });
+            if (hint && hint.event_id) {
+                event.event_id = hint.event_id;
+            }
 
             if (isFatal) {
                 event.level = 'fatal' as SeverityLevel;
-
                 addExceptionMechanism(event, {
                     handled: false,
                     type: 'onerror',
                 });
             }
 
-            const result = client.captureEvent(event);
-            console.log('globalHander2', result, Object.keys(event));
+            client.captureEvent(event);
         } catch (error) {
             console.error(error);
         }

src/integrations/screenshot.ts

@@ -0,0 +1,45 @@
+import { EventHint, Integration } from '@sentry/types';
+import { resolvedSyncPromise } from '@sentry/utils';
+
+import { NATIVE } from '../wrapper';
+
+/** Adds screenshots to error events */
+export class Screenshot implements Integration {
+    /**
+   * @inheritDoc
+   */
+    public static id: string = 'Screenshot';
+
+    /**
+   * @inheritDoc
+   */
+    public name: string = Screenshot.id;
+
+    /**
+   * If enabled attaches a screenshot to the event hint.
+   */
+    public static  attachScreenshotToEventHint(
+        hint: EventHint,
+        { attachScreenshot }: { attachScreenshot?: boolean },
+    ): EventHint {
+        if (!attachScreenshot) {
+            return (hint);
+        }
+
+        const  screenshots = NATIVE.captureScreenshot();
+        if (screenshots !== null && screenshots.length > 0) {
+            hint.attachments = [
+                ...screenshots,
+                ...(hint?.attachments || []),
+            ];
+        }
+        console.log('attachScreenshotToEventHint', screenshots, hint.attachments);
+        return hint;
+    }
+
+    /**
+   * @inheritDoc
+   */
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    public setupOnce(): void {}
+}

src/options.ts

@@ -51,6 +51,13 @@ export interface BaseNativescriptOptions {
     /** When enabled, all the threads are automatically attached to all logged events on Android */
     attachThreads?: boolean;
 
+    /**
+   * When enabled and a user experiences an error, Sentry provides the ability to take a screenshot and include it as an attachment.
+   *
+   * @default false
+   */
+    attachScreenshot?: boolean;
+
     /**
    *  When enabled, certain personally identifiable information (PII) is added by active integrations.
    *

src/sdk.ts

@@ -18,6 +18,7 @@ import { makeUtf8TextEncoder } from './transports/TextEncoder';
 import { safeFactory, safeTracesSampler } from './utils/safe';
 import { NATIVE } from './wrapper';
 import { parseErrorStack } from './integrations/debugsymbolicator';
+import { Screenshot } from './integrations/screenshot';
 
 
 const STACKTRACE_LIMIT = 50;
@@ -160,6 +161,9 @@ export function init(passedOptions: NativescriptOptions): void {
                 defaultIntegrations.push(new NativescriptTracing());
             }
         }
+        if (options.attachScreenshot) {
+            defaultIntegrations.push(new Screenshot());
+        }
     }
     options.integrations = getIntegrationsToSetup({
         integrations: safeFactory(passedOptions.integrations, { loggerMessage: 'The integrations threw an error' }),