@nativescript-community/sentry 2.0.8 → 3.0.2

package/integrations/sdkinfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdkinfo.js","sourceRoot":"","sources":["../../src/integrations/sdkinfo.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,sCAAsC;AACtC,MAAM,OAAO,OAAO;IAApB;QAME;;WAEG;QACI,SAAI,GAAW,OAAO,CAAC,EAAE,CAAC;QAEzB,mBAAc,GAAmB,IAAI,CAAC;IAuChD,CAAC;IArCC;;OAEG;IACI,SAAS,CAAC,uBAAoD;QACnE,uBAAuB,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;;YACtC,2GAA2G;YAC3G,+FAA+F;YAC/F,IAAI,MAAM,CAAC,KAAK,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,EAAE;gBAChD,IAAI;oBACF,IAAI,CAAC,cAAc,GAAG,MAAM,QAAQ,CAAC,kBAAkB,EAAE,CAAC;iBAC3D;gBAAC,OAAO,CAAC,EAAE;oBACV,qGAAqG;oBACrG,MAAM,CAAC,IAAI,CACT,sGAAsG,CACvG,CAAC;oBACF,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;iBAChB;aACF;YAED,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,YAAY,CAAC;YAChD,KAAK,CAAC,GAAG,mCACJ,OAAC,KAAK,CAAC,GAAG,mCAAI,EAAE,CAAC,KACpB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE;oBACR,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;oBAC5C,GAAG,CAAC,CAAC,IAAI,CAAC,cAAc,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,IAAI,EAAE,CAAC;oBACzD;wBACE,IAAI,EAAE,oCAAoC;wBAC1C,OAAO,EAAE,WAAW;qBACrB;iBACF,EACD,OAAO,EAAE,WAAW,GACrB,CAAC;YAEF,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CAAC;IACL,CAAC;;AAhDD;;GAEG;AACW,UAAE,GAAW,SAAS,CAAC"}

package/nssentry.android.d.ts

@@ -1,17 +1,29 @@
-import { Event, Response } from '@sentry/types';
+import { Breadcrumb, Event, Response, User } from '@sentry/types';
 import { NativescriptOptions } from './backend';
+import { UserFeedback } from './nssentry';
 export declare namespace NSSentry {
     const nativeClientAvailable = true;
     const nativeTransport = true;
-    function fetchRelease(): {
-        id: string;
-        version: string;
-        build: number;
-    };
     function sendEvent(event: Event): Promise<Response>;
+    function captureEnvelope(envelope: string): Promise<void>;
     function flush(timeout: number): void;
-    function startWithDsnString(dsnString: string, options: NativescriptOptions): Promise<Response>;
-    function setLogLevel(level: number): void;
+    function startWithDsnString(dsnString: string, options?: NativescriptOptions): Promise<Response>;
+    function fetchNativeSdkInfo(): {};
+    function fetchNativeRelease(): {
+        id: any;
+        version: any;
+        build: string;
+    };
+    function closeNativeSdk(): void;
     function crash(): void;
     function deviceContexts(): Promise<any>;
+    function captureUserFeedback(feedback: UserFeedback): void;
+    function setUser(user: User | null, otherUserKeys: any): void;
+    function setTag(key: string, value: string): void;
+    function setExtra(key: string, extra: string): void;
+    function addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): void;
+    function clearBreadcrumbs(): void;
+    function setContext(key: string, context: {
+        [key: string]: any;
+    } | null): void;
 }

package/nssentry.android.js

@@ -1,35 +1,26 @@
 import { Application } from '@nativescript/core';
+import { android as androidApp } from '@nativescript/core/application';
 import { Status } from '@sentry/types';
-import { rewriteFrameIntegration } from './sdk';
+import { _processLevel } from './backend';
 import { convertNativescriptFramesToSentryFrames, parseErrorStack } from './integrations/debugsymbolicator';
+import { rewriteFrameIntegration } from './sdk';
 export var NSSentry;
 (function (NSSentry) {
     NSSentry.nativeClientAvailable = true;
     NSSentry.nativeTransport = true;
-    function fetchRelease() {
-        const ctx = Application.android.context;
-        const packageInfo = ctx.getPackageManager().getPackageInfo(ctx.getPackageName(), 0);
-        return {
-            id: packageInfo.packageName,
-            version: packageInfo.versionName,
-            build: packageInfo.versionCode,
-        };
-    }
-    NSSentry.fetchRelease = fetchRelease;
     function eventLevel(level) {
         switch (level) {
             case 'fatal':
-                return io.sentry.core.SentryLevel.FATAL;
+                return io.sentry.SentryLevel.FATAL;
             case 'warning':
-                return io.sentry.core.SentryLevel.WARNING;
+                return io.sentry.SentryLevel.WARNING;
             case 'info':
-                return io.sentry.core.SentryLevel.INFO;
             case 'log':
-                return io.sentry.core.SentryLevel.LOG;
+                return io.sentry.SentryLevel.INFO;
             case 'debug':
-                return io.sentry.core.SentryLevel.DEBUG;
+                return io.sentry.SentryLevel.DEBUG;
             default:
-                return io.sentry.core.SentryLevel.ERROR;
+                return io.sentry.SentryLevel.ERROR;
         }
     }
     function getNativeHashMap(obj) {
@@ -69,7 +60,7 @@ export var NSSentry;
         return result;
     }
     function getUser(user) {
-        const nUser = new io.sentry.core.protocol.User();
+        const nUser = new io.sentry.protocol.User();
         if (user.email) {
             nUser.setEmail(user.email);
         }
@@ -90,10 +81,10 @@ export var NSSentry;
         }
         return nUser;
     }
-    const mJsModuleIdPattern = new RegExp('(?:^|[/\\\\])(\\d+\\.js)$').compile();
+    const mJsModuleIdPattern = new RegExp('(?:^|[/\\\\])(\\d+\\.js)$');
     function stackFrameToModuleId(frame) {
         if (!!frame.file) {
-            const matcher = frame.file.match(mJsModuleIdPattern);
+            const matcher = mJsModuleIdPattern.exec(frame.file);
             if (matcher) {
                 return matcher[1] + ':';
             }
@@ -101,7 +92,7 @@ export var NSSentry;
         return '';
     }
     function convertToNativeStacktrace(stack) {
-        const nStackTrace = new io.sentry.core.protocol.SentryStackTrace();
+        const nStackTrace = new io.sentry.protocol.SentryStackTrace();
         const frames = new java.util.ArrayList();
         for (let i = 0; i < stack.length; i++) {
             const frame = stack[i];
@@ -109,7 +100,7 @@ export var NSSentry;
             const methodName = frame.methodName || frame.function || '';
             const lineNumber = frame.lineNumber || frame.lineno || 0;
             const column = frame.column || frame.colno || 0;
-            const stackFrame = new io.sentry.core.protocol.SentryStackFrame();
+            const stackFrame = new io.sentry.protocol.SentryStackFrame();
             stackFrame.setModule('');
             stackFrame.setFunction(methodName.length > 0 ? methodName.split('.').pop() : methodName);
             stackFrame.setFilename(stackFrameToModuleId(frame));
@@ -125,7 +116,7 @@ export var NSSentry;
     }
     function addExceptionInterface(nEvent, type, value, stack) {
         const exceptions = nEvent.getExceptions() || new java.util.ArrayList();
-        const nException = new io.sentry.core.protocol.SentryException();
+        const nException = new io.sentry.protocol.SentryException();
         nException.setType(type);
         nException.setValue(value);
         nException.setModule('');
@@ -137,158 +128,81 @@ export var NSSentry;
     }
     function sendEvent(event) {
         return new Promise((resolve) => {
-            const nEvent = new io.sentry.core.SentryEvent();
-            if (event.event_id) {
-                nEvent.setEventId(new io.sentry.core.protocol.SentryId(event.event_id));
-            }
-            if (event.breadcrumbs) {
-                const breadcrumbs = event.breadcrumbs;
-                const eventBreadcrumbs = new java.util.ArrayList();
-                for (let i = 0; i < breadcrumbs.length; i++) {
-                    const breadcrumb = breadcrumbs[i];
-                    const nBreadcumb = new io.sentry.core.Breadcrumb();
-                    if (breadcrumb.category) {
-                        nBreadcumb.setCategory(breadcrumb.category);
-                    }
-                    if (breadcrumb.type) {
-                        const typeString = breadcrumb.type.toUpperCase();
-                        try {
-                            nBreadcumb.setType(typeString);
-                        }
-                        catch (e) {
-                            // don't copy over invalid breadcrumb 'type' value
-                        }
-                    }
-                    if (breadcrumb.level) {
-                        nBreadcumb.setLevel(eventLevel(breadcrumb.level));
-                    }
-                    try {
-                        if (breadcrumb.data) {
-                            Object.keys(breadcrumb.data).forEach((k) => {
-                                const value = breadcrumb.data[k];
-                                // in case a `status_code` entry got accidentally stringified as a float
-                                if (k === 'status_code') {
-                                    nBreadcumb.setData(k, value && value.endsWith('.0') ? value.replace('.0', '') : value);
-                                }
-                                else {
-                                    nBreadcumb.setData(k, value);
-                                }
-                            });
-                        }
-                    }
-                    catch (e) {
-                        console.warn('Discarded breadcrumb.data since it was not an object');
-                    }
-                    if (breadcrumb.message) {
-                        nBreadcumb.setMessage(breadcrumb.message);
-                    }
-                    else {
-                        nBreadcumb.setMessage('');
-                    }
-                    eventBreadcrumbs.add(i, nBreadcumb);
-                }
-                if (eventBreadcrumbs.size() > 0) {
-                    nEvent.setBreadcrumbs(eventBreadcrumbs);
-                }
-            }
-            if (event.message) {
-                const nMsg = new io.sentry.core.protocol.Message();
-                nMsg.setMessage(event.message || '');
-                nEvent.setMessage(nMsg);
-            }
-            if (event.logger) {
-                nEvent.setLogger(event.logger);
-            }
-            if (event.user) {
-                nEvent.setUser(getUser(event.user));
-            }
-            if (event.extra) {
-                Object.keys(event.extra).forEach((k) => {
-                    const value = event.extra[k];
-                    nEvent.setExtra(k, typeof value === 'string' ? value : JSON.stringify(value));
-                });
+            var _a;
+            // Process and convert deprecated levels
+            event.level = event.level ? _processLevel(event.level) : undefined;
+            const header = {
+                event_id: event.event_id,
+                sdk: event.sdk,
+            };
+            const payload = Object.assign(Object.assign({}, event), { message: {
+                    message: event.message,
+                } });
+            const headerString = JSON.stringify(header);
+            const payloadString = JSON.stringify(payload);
+            const length = payloadString.length;
+            // try {
+            //     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            //     length = await RNSentry.getStringBytesLength(payloadString);
+            // } catch {
+            //     // The native call failed, we do nothing, we have payload.length as a fallback
+            // }
+            const item = {
+                content_type: 'application/json',
+                length,
+                type: (_a = payload.type) !== null && _a !== void 0 ? _a : 'event',
+            };
+            const itemString = JSON.stringify(item);
+            const envelopeString = `${headerString}\n${itemString}\n${payloadString}`;
+            captureEnvelope(envelopeString);
+            if (sentryOptions.flushSendEvent === true) {
+                io.sentry.Sentry.flush(0);
             }
-            if (event.fingerprint) {
-                const fingerprint = event.fingerprint;
-                const print = new java.util.ArrayList();
-                for (let i = 0; i < fingerprint.length; ++i) {
-                    print.add(fingerprint[i]);
-                }
-                nEvent.setFingerprints(print);
-            }
-            if (event.tags) {
-                Object.keys(event.tags).forEach((k) => {
-                    const value = event.tags[k];
-                    nEvent.setTag(k, value || 'INVALID_TAG');
-                });
-            }
-            if (event.exception) {
-                const exceptionValues = event.exception.values;
-                const exception = exceptionValues[0];
-                if (exception.stacktrace) {
-                    const stacktrace = exception.stacktrace;
-                    const frames = stacktrace.frames;
-                    if (exception.value) {
-                        addExceptionInterface(nEvent, exception.type, exception.value, frames);
-                    }
-                    else {
-                        // We use type/type here since this indicates an Unhandled Promise Rejection
-                        // https://github.com/getsentry/react-native-sentry/issues/353
-                        addExceptionInterface(nEvent, exception.type, exception.type, frames);
-                    }
-                }
-            }
-            if (event.environment) {
-                nEvent.setEnvironment(event.environment);
-            }
-            if (event.platform) {
-                nEvent.setPlatform(event.platform);
-            }
-            if (event.release) {
-                nEvent.setRelease(event.release);
-            }
-            if (event.dist) {
-                nEvent.setDist(event.dist);
-            }
-            if (event.level) {
-                nEvent.setLevel(eventLevel(event.level));
-            }
-            if (event.contexts) {
-                Object.keys(event.contexts).forEach((k) => {
-                    // const value = event.contexts[k];
-                    // const context = new io.sentry.core.protocol.Contexts();
-                    // nEvent.setTag(k, value || 'INVALID_TAG');
-                });
-            }
-            if (event.sdk) {
-                const sdk = event.sdk;
-                const nSdk = new io.sentry.core.protocol.SdkVersion();
-                nSdk.setName(sdk.name);
-                nSdk.setVersion(sdk.version);
-                if (sdk.integrations) {
-                    const integrations = sdk.integrations;
-                    for (let i = 0; i < integrations.length; ++i) {
-                        nSdk.addIntegration(integrations[i]);
-                    }
-                }
-                nEvent.setSdk(nSdk);
-            }
-            const id = io.sentry.core.Sentry.captureEvent(nEvent);
-            // io.sentry.core.Sentry.flush(0);
-            resolve({ status: Status.Success, id });
+            resolve({ status: Status.Success });
         }).catch((err) => {
             console.error('error sending sentry event', err, err.stack);
             return Promise.reject(err);
         });
     }
     NSSentry.sendEvent = sendEvent;
+    async function captureEnvelope(envelope) {
+        const installation = new java.io.File(nSentryOptions.getOutboxPath(), java.util.UUID.randomUUID().toString());
+        try {
+            const out = new java.io.FileOutputStream(installation);
+            out.write(new java.lang.String(envelope).getBytes(java.nio.charset.Charset.forName('UTF-8')));
+        }
+        catch (err) {
+            console.error('captureEnvelope error', err);
+        }
+    }
+    NSSentry.captureEnvelope = captureEnvelope;
     function flush(timeout) {
-        console.log('native flush', timeout);
-        io.sentry.core.Sentry.flush(timeout);
+        io.sentry.Sentry.flush(timeout);
     }
     NSSentry.flush = flush;
     let initialized = false;
-    function startWithDsnString(dsnString, options) {
+    let sentryOptions;
+    let nSentryOptions;
+    function addPackages(event, sdk) {
+        const eventSdk = event.getSdk();
+        if (eventSdk != null && eventSdk.getName() === 'sentry.javascript.react-native' && sdk != null) {
+            const sentryPackages = sdk.getPackages();
+            if (sentryPackages != null) {
+                for (let index = 0; index < sentryPackages.size(); index++) {
+                    const sentryPackage = sentryPackages.get(index);
+                    eventSdk.addPackage(sentryPackage.getName(), sentryPackage.getVersion());
+                }
+            }
+            const integrations = sdk.getIntegrations();
+            if (integrations != null) {
+                for (let index = 0; index < integrations.size(); index++) {
+                    eventSdk.addIntegration(integrations.get(index));
+                }
+            }
+            event.setSdk(eventSdk);
+        }
+    }
+    function startWithDsnString(dsnString, options = {}) {
         return new Promise((resolve, reject) => {
             if (initialized) {
                 console.info('Already started, use existing client', dsnString);
@@ -296,16 +210,18 @@ export var NSSentry;
                 return;
             }
             try {
-                io.sentry.android.core.SentryAndroid.init(Application.android.context, new io.sentry.core.Sentry.OptionsConfiguration({
+                io.sentry.android.core.SentryAndroid.init(Application.android.context, new io.sentry.Sentry.OptionsConfiguration({
                     configure(config) {
-                        config.setLogger(new io.sentry.core.SystemOutLogger());
-                        // config.setDiagnosticLevel(io.sentry.core.SentryLevel.DEBUG);
-                        // io.sentry.core.Sentry.setLevel(io.sentry.core.SentryLevel.DEBUG);
+                        // config.setLogger(new io.sentry.SystemOutLogger());
+                        // config.setDiagnosticLevel(io.sentry.SentryLevel.DEBUG);
+                        io.sentry.Sentry.setLevel(io.sentry.SentryLevel.DEBUG);
                         config.setDsn(dsnString);
-                        config.setEnvironment('javascript');
                         if (!!options.environment) {
                             config.setEnvironment(options.environment);
                         }
+                        else {
+                            config.setEnvironment('javascript');
+                        }
                         if (!!options.debug) {
                             config.setDebug(options.debug);
                         }
@@ -318,20 +234,37 @@ export var NSSentry;
                         if (options.enableAutoSessionTracking !== undefined) {
                             config.setEnableSessionTracking(options.enableAutoSessionTracking);
                         }
-                        config.setEnableNdk(true);
+                        if (options.sessionTrackingIntervalMillis !== undefined) {
+                            config.setSessionTrackingIntervalMillis(options.sessionTrackingIntervalMillis);
+                        }
+                        if (options.enableNdkScopeSync !== undefined) {
+                            config.setEnableScopeSync(options.enableNdkScopeSync);
+                        }
+                        if (options.attachStacktrace !== undefined) {
+                            config.setAttachStacktrace(options.attachStacktrace);
+                        }
+                        if (options.attachThreads !== undefined) {
+                            // JS use top level stacktraces and android attaches Threads which hides them so
+                            // by default we hide.
+                            config.setAttachThreads(options.attachThreads);
+                        }
+                        if (options.sendDefaultPii !== undefined) {
+                            config.setSendDefaultPii(options.sendDefaultPii);
+                        }
+                        // config.setEnableNdk(true);
                         const integrations = config.getIntegrations();
                         const size = integrations.size();
                         if (options.enableNativeCrashHandling === false) {
                             for (let index = size - 1; index >= 0; index--) {
                                 const inte = integrations.get(index);
-                                if (inte instanceof io.sentry.core.UncaughtExceptionHandlerIntegration ||
+                                if (inte instanceof io.sentry.UncaughtExceptionHandlerIntegration ||
                                     inte instanceof io.sentry.android.core.AnrIntegration ||
                                     inte instanceof io.sentry.android.core.NdkIntegration) {
                                     integrations.remove(index);
                                 }
                             }
                         }
-                        config.setBeforeSend(new io.sentry.core.SentryOptions.BeforeSendCallback({
+                        config.setBeforeSend(new io.sentry.SentryOptions.BeforeSendCallback({
                             execute(event, hint) {
                                 if (options.beforeSend) {
                                     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
@@ -346,27 +279,39 @@ export var NSSentry;
                                 try {
                                     const ex = event.getExceptions().get(0);
                                     if (ex && ex.getType() === 'NativeScriptException') {
-                                        const privateMethod = io.sentry.core.SentryEvent.class.getDeclaredMethod('getThrowable', null);
-                                        privateMethod.setAccessible(true);
-                                        const returnValue = privateMethod.invoke(event, null);
-                                        if (returnValue instanceof io.sentry.core.exception.ExceptionMechanismException) {
-                                            const throwable = returnValue.getThrowable();
-                                            if (throwable instanceof com.tns.NativeScriptException) {
-                                                const jsStackTrace = throwable.getIncomingStackTrace();
-                                                if (jsStackTrace) {
-                                                    const stack = parseErrorStack({ stack: jsStackTrace });
-                                                    const convertedFrames = convertNativescriptFramesToSentryFrames(stack);
-                                                    convertedFrames.forEach((frame) => rewriteFrameIntegration._iteratee(frame));
-                                                    addExceptionInterface(event, 'Error', throwable.getMessage(), convertedFrames.reverse());
-                                                }
+                                        let mechanism = event.getThrowable && event.getThrowable();
+                                        if (!mechanism) {
+                                            const privateMethod = io.sentry.SentryEvent.class.getDeclaredMethod('getThrowable', null);
+                                            privateMethod.setAccessible(true);
+                                            mechanism = privateMethod.invoke(event, null);
+                                        }
+                                        let throwable;
+                                        if (mechanism instanceof io.sentry.exception.ExceptionMechanismException) {
+                                            throwable = mechanism.getThrowable();
+                                        }
+                                        else if (mechanism instanceof com.tns.NativeScriptException) {
+                                            throwable = mechanism;
+                                        }
+                                        if (throwable) {
+                                            const jsStackTrace = (throwable).getIncomingStackTrace();
+                                            if (jsStackTrace) {
+                                                const stack = parseErrorStack({ stack: jsStackTrace });
+                                                const convertedFrames = convertNativescriptFramesToSentryFrames(stack);
+                                                convertedFrames.forEach((frame) => rewriteFrameIntegration._iteratee(frame));
+                                                addExceptionInterface(event, 'Error', throwable.getMessage(), convertedFrames.reverse());
                                             }
                                         }
                                     }
                                 }
                                 catch (e) { }
+                                event.setTag('event.origin', 'android');
+                                event.setTag('event.environment', 'nativescript');
+                                addPackages(event, config.getSdkVersion());
                                 return event;
                             },
                         }));
+                        nSentryOptions = config;
+                        sentryOptions = options;
                     },
                 }));
                 initialized = true;
@@ -380,30 +325,47 @@ export var NSSentry;
         });
     }
     NSSentry.startWithDsnString = startWithDsnString;
-    function setLogLevel(level) {
-        switch (level) {
-            case 1:
-                io.sentry.core.Sentry.setLevel(null);
-                break;
-            case 2:
-                io.sentry.core.Sentry.setLevel(io.sentry.core.SentryLevel.ERROR);
-                break;
-            case 3:
-                io.sentry.core.Sentry.setLevel(io.sentry.core.SentryLevel.DEBUG);
-                break;
-            case 4:
-                io.sentry.core.Sentry.setLevel(io.sentry.core.SentryLevel.LOG);
-                break;
-        }
+    // export function setLogLevel(level: number) {
+    //     switch (level) {
+    //         case 1:
+    //             io.sentry.Sentry.setLevel(null);
+    //             break;
+    //         case 2:
+    //             io.sentry.Sentry.setLevel(io.sentry.SentryLevel.ERROR);
+    //             break;
+    //         case 3:
+    //             io.sentry.Sentry.setLevel(io.sentry.SentryLevel.DEBUG);
+    //             break;
+    //         case 4:
+    //             io.sentry.Sentry.setLevel(io.sentry.SentryLevel.INFO);
+    //             break;
+    //     }
+    // }
+    function fetchNativeSdkInfo() {
+        return {};
+    }
+    NSSentry.fetchNativeSdkInfo = fetchNativeSdkInfo;
+    function fetchNativeRelease() {
+        const context = androidApp.context;
+        const packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+        return {
+            'id': packageInfo.packageName,
+            'version': packageInfo.versionName,
+            'build': packageInfo.versionCode + ''
+        };
+    }
+    NSSentry.fetchNativeRelease = fetchNativeRelease;
+    function closeNativeSdk() {
+        io.sentry.Sentry.close();
     }
-    NSSentry.setLogLevel = setLogLevel;
+    NSSentry.closeNativeSdk = closeNativeSdk;
     function crash() {
         throw new java.lang.RuntimeException('TEST - Sentry Client Crash');
     }
     NSSentry.crash = crash;
     function deviceContexts() {
         return new Promise((resolve) => {
-            const nEvent = new io.sentry.core.SentryEvent();
+            const nEvent = new io.sentry.SentryEvent();
             const params = {};
             const it = nEvent.getContexts().entrySet().iterator();
             let value, pair, key;
@@ -417,5 +379,105 @@ export var NSSentry;
         });
     }
     NSSentry.deviceContexts = deviceContexts;
+    function captureUserFeedback(feedback) {
+        const userFeedback = new io.sentry.UserFeedback(new io.sentry.protocol.SentryId(feedback.eventId));
+        if (feedback.comments) {
+            userFeedback.setComments(feedback.comments);
+        }
+        if (feedback.email) {
+            userFeedback.setEmail(feedback.email);
+        }
+        if (feedback.name) {
+            userFeedback.setName(feedback.name);
+        }
+        io.sentry.Sentry.captureUserFeedback(userFeedback);
+    }
+    NSSentry.captureUserFeedback = captureUserFeedback;
+    function setUser(user, otherUserKeys) {
+        io.sentry.Sentry.configureScope(new io.sentry.ScopeCallback({
+            run(scope) {
+                if (user == null && otherUserKeys == null) {
+                    scope.setUser(null);
+                }
+                else {
+                    const userInstance = new io.sentry.protocol.User();
+                    if (user) {
+                        if (user.email) {
+                            userInstance.setEmail(user.email);
+                        }
+                        if (user.id) {
+                            userInstance.setId(user.id);
+                        }
+                        if (user.username) {
+                            userInstance.setUsername(user.username);
+                        }
+                        if (user.ip_address) {
+                            userInstance.setIpAddress(user.ip_address);
+                        }
+                    }
+                    if (otherUserKeys) {
+                        userInstance.setOthers(getNativeHashMap(otherUserKeys));
+                    }
+                    scope.setUser(userInstance);
+                }
+            }
+        }));
+    }
+    NSSentry.setUser = setUser;
+    function setTag(key, value) {
+        io.sentry.Sentry.configureScope(new io.sentry.ScopeCallback({
+            run(scope) {
+                scope.setTag(key, value);
+            }
+        }));
+    }
+    NSSentry.setTag = setTag;
+    function setExtra(key, extra) {
+        io.sentry.Sentry.configureScope(new io.sentry.ScopeCallback({
+            run(scope) {
+                scope.setExtra(key, extra);
+            }
+        }));
+    }
+    NSSentry.setExtra = setExtra;
+    function addBreadcrumb(breadcrumb, maxBreadcrumbs) {
+        io.sentry.Sentry.configureScope(new io.sentry.ScopeCallback({
+            run(scope) {
+                const breadcrumbInstance = new io.sentry.Breadcrumb();
+                if (breadcrumb.message) {
+                    breadcrumbInstance.setMessage(breadcrumb.message);
+                }
+                if (breadcrumb.type) {
+                    breadcrumbInstance.setType(breadcrumb.type);
+                }
+                if (breadcrumb.category) {
+                    breadcrumbInstance.setCategory(breadcrumb.category);
+                }
+                if (breadcrumb.level) {
+                    breadcrumbInstance.setLevel(eventLevel(breadcrumb.level));
+                }
+                if (breadcrumb.data) {
+                    Object.keys(breadcrumb.data).forEach(key => {
+                        breadcrumbInstance.setData(key, breadcrumb.data[key]);
+                    });
+                }
+                scope.addBreadcrumb(breadcrumbInstance);
+            }
+        }));
+    }
+    NSSentry.addBreadcrumb = addBreadcrumb;
+    function clearBreadcrumbs() {
+        io.sentry.Sentry.configureScope(new io.sentry.ScopeCallback({
+            run(scope) {
+                scope.clearBreadcrumbs();
+            }
+        }));
+    }
+    NSSentry.clearBreadcrumbs = clearBreadcrumbs;
+    function setContext(key, context) {
+        // setContext not available on the Android SDK yet.
+        setExtra(key, context ? JSON.stringify(context) : null);
+    }
+    NSSentry.setContext = setContext;
 })(NSSentry || (NSSentry = {}));
 //# sourceMappingURL=nssentry.android.js.map