feat(serverless): Mark errors caught in Serverless handlers as unhandled

packages/serverless/src/awslambda.ts

@@ -14,7 +14,7 @@ import { performance } from 'perf_hooks';
 import { types } from 'util';
 
 import { AWSServices } from './awsservices';
-import { serverlessEventProcessor } from './utils';
+import { markEventUnhandled, serverlessEventProcessor } from './utils';
 
 export * from '@sentry/node';
 
@@ -312,11 +312,11 @@ export function wrapHandler<TEvent, TResult>(
  if (options.captureAllSettledReasons && Array.isArray(rv) && isPromiseAllSettledResult(rv)) {
  const reasons = getRejectedReasons(rv);
  reasons.forEach(exception => {
- captureException(exception);
+ captureException(exception, scope => markEventUnhandled(scope));
  });
  }
  } catch (e) {
- captureException(e);
+ captureException(e, scope => markEventUnhandled(scope));
  throw e;
  } finally {
  clearTimeout(timeoutWarningTimer);

packages/serverless/src/gcpfunction/cloud_events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { CloudEventFunction, CloudEventFunctionWithCallback, WrapperOptions } from './general';
 
 export type CloudEventFunctionWrapperOptions = WrapperOptions;
@@ -50,7 +50,7 @@ function _wrapCloudEventFunction(
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -68,13 +68,13 @@ function _wrapCloudEventFunction(
  try {
  fnResult = (fn as CloudEventFunctionWithCallback)(context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { EventFunction, EventFunctionWithCallback, WrapperOptions } from './general';
 
 export type EventFunctionWrapperOptions = WrapperOptions;
@@ -52,7 +52,7 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -72,13 +72,13 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
  try {
  fnResult = (fn as EventFunctionWithCallback)(data, context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/http.ts

@@ -2,7 +2,7 @@ import type { AddRequestDataToEventOptions } from '@sentry/node';
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isString, isThenable, logger, stripUrlQueryAndFragment, tracingContextFromHeaders } from '@sentry/utils';
 
-import { domainify, proxyFunction } from './../utils';
+import { domainify, markEventUnhandled, proxyFunction } from './../utils';
 import type { HttpFunction, WrapperOptions } from './general';
 
 // TODO (v8 / #5257): Remove this whole old/new business and just use the new stuff
@@ -122,13 +122,13 @@ function _wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<HttpFunctionWr
  try {
  fnResult = fn(req, res);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/utils.ts

@@ -1,5 +1,6 @@
 import { runWithAsyncContext } from '@sentry/core';
 import type { Event } from '@sentry/node';
+import type { Scope } from '@sentry/types';
 import { addExceptionMechanism } from '@sentry/utils';
 
 /**
@@ -55,3 +56,15 @@ export function proxyFunction<A extends any[], R, F extends (...args: A) => R>(
 
  return new Proxy(source, handler);
 }
+
+/**
+ * Marks an event as unhandled by adding a span processor to the passed scope.
+ */
+export function markEventUnhandled(scope: Scope): Scope {
+ scope.addEventProcessor(event => {
+ addExceptionMechanism(event, { handled: false });
+ return event;
+ });
+
+ return scope;
+}

packages/serverless/test/awslambda.test.ts

@@ -1,6 +1,7 @@
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 // eslint-disable-next-line import/no-unresolved
 import type { Callback, Handler } from 'aws-lambda';
 
@@ -175,8 +176,8 @@ describe('AWSLambda', () => {
  ]);
  const wrappedHandler = wrapHandler(handler, { flushTimeout: 1337, captureAllSettledReasons: true });
  await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2);
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error, expect.any(Function));
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2, expect.any(Function));
  expect(SentryNode.captureException).toBeCalledTimes(2);
  });
  });
@@ -229,7 +230,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalledWith(2000);
@@ -308,7 +309,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(e);
+ expect(SentryNode.captureException).toBeCalledWith(e, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -375,7 +376,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -457,14 +458,42 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
  }
  });
  });
 
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(3);
+
+ const error = new Error('wat');
+ const handler: Handler = async (_event, _context, _callback) => {
+ throw error;
+ };
+ const wrappedHandler = wrapHandler(handler);
+
+ try {
+ await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+ } catch (e) {
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ // @ts-ignore see "Why @ts-ignore" note
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
+ });
+ }
+ });
+
  describe('init()', () => {
  test('calls Sentry.init with correct sdk info metadata', () => {
  Sentry.AWSLambda.init({});

packages/serverless/test/gcpfunction.test.ts

@@ -1,4 +1,5 @@
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 import * as domain from 'domain';
 
 import * as Sentry from '../src';
@@ -12,7 +13,6 @@ import type {
  Request,
  Response,
 } from '../src/gcpfunction/general';
-
 /**
  * Why @ts-ignore some Sentry.X calls
  *
@@ -198,7 +198,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -317,7 +317,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -382,7 +382,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -440,7 +440,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -469,7 +469,33 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ });
+ });
+
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(4);
+
+ const error = new Error('wat');
+ const handler: EventFunctionWithCallback = (_data, _context, _cb) => {
+ throw error;
+ };
+ const wrappedHandler = wrapEventFunction(handler);
+ await expect(handleEvent(wrappedHandler)).rejects.toThrowError(error);
+
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+
+ // @ts-ignore just mocking around...
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
  });
  });
 
@@ -537,7 +563,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -595,7 +621,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -625,7 +651,7 @@ describe('GCPFunction', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
 
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  });
  });
 

packages/serverless/src/awslambda.ts

@@ -14,7 +14,7 @@ import { performance } from 'perf_hooks';
 import { types } from 'util';
 
 import { AWSServices } from './awsservices';
-import { serverlessEventProcessor } from './utils';
+import { markEventUnhandled, serverlessEventProcessor } from './utils';
 
 export * from '@sentry/node';
 
@@ -312,11 +312,11 @@ export function wrapHandler<TEvent, TResult>(
  if (options.captureAllSettledReasons && Array.isArray(rv) && isPromiseAllSettledResult(rv)) {
  const reasons = getRejectedReasons(rv);
  reasons.forEach(exception => {
- captureException(exception);
+ captureException(exception, scope => markEventUnhandled(scope));
  });
  }
  } catch (e) {
- captureException(e);
+ captureException(e, scope => markEventUnhandled(scope));
  throw e;
  } finally {
  clearTimeout(timeoutWarningTimer);

packages/serverless/src/gcpfunction/cloud_events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { CloudEventFunction, CloudEventFunctionWithCallback, WrapperOptions } from './general';
 
 export type CloudEventFunctionWrapperOptions = WrapperOptions;
@@ -50,7 +50,7 @@ function _wrapCloudEventFunction(
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -68,13 +68,13 @@ function _wrapCloudEventFunction(
  try {
  fnResult = (fn as CloudEventFunctionWithCallback)(context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { EventFunction, EventFunctionWithCallback, WrapperOptions } from './general';
 
 export type EventFunctionWrapperOptions = WrapperOptions;
@@ -52,7 +52,7 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -72,13 +72,13 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
  try {
  fnResult = (fn as EventFunctionWithCallback)(data, context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/http.ts

@@ -2,7 +2,7 @@ import type { AddRequestDataToEventOptions } from '@sentry/node';
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isString, isThenable, logger, stripUrlQueryAndFragment, tracingContextFromHeaders } from '@sentry/utils';
 
-import { domainify, proxyFunction } from './../utils';
+import { domainify, markEventUnhandled, proxyFunction } from './../utils';
 import type { HttpFunction, WrapperOptions } from './general';
 
 // TODO (v8 / #5257): Remove this whole old/new business and just use the new stuff
@@ -122,13 +122,13 @@ function _wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<HttpFunctionWr
  try {
  fnResult = fn(req, res);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/utils.ts

@@ -1,5 +1,6 @@
 import { runWithAsyncContext } from '@sentry/core';
 import type { Event } from '@sentry/node';
+import type { Scope } from '@sentry/types';
 import { addExceptionMechanism } from '@sentry/utils';
 
 /**
@@ -55,3 +56,15 @@ export function proxyFunction<A extends any[], R, F extends (...args: A) => R>(
 
  return new Proxy(source, handler);
 }
+
+/**
+ * Marks an event as unhandled by adding a span processor to the passed scope.
+ */
+export function markEventUnhandled(scope: Scope): Scope {
+ scope.addEventProcessor(event => {
+ addExceptionMechanism(event, { handled: false });
+ return event;
+ });
+
+ return scope;
+}

packages/serverless/test/awslambda.test.ts

@@ -1,6 +1,7 @@
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 // eslint-disable-next-line import/no-unresolved
 import type { Callback, Handler } from 'aws-lambda';
 
@@ -175,8 +176,8 @@ describe('AWSLambda', () => {
  ]);
  const wrappedHandler = wrapHandler(handler, { flushTimeout: 1337, captureAllSettledReasons: true });
  await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2);
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error, expect.any(Function));
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2, expect.any(Function));
  expect(SentryNode.captureException).toBeCalledTimes(2);
  });
  });
@@ -229,7 +230,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalledWith(2000);
@@ -308,7 +309,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(e);
+ expect(SentryNode.captureException).toBeCalledWith(e, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -375,7 +376,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -457,14 +458,42 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
  }
  });
  });
 
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(3);
+
+ const error = new Error('wat');
+ const handler: Handler = async (_event, _context, _callback) => {
+ throw error;
+ };
+ const wrappedHandler = wrapHandler(handler);
+
+ try {
+ await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+ } catch (e) {
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ // @ts-ignore see "Why @ts-ignore" note
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
+ });
+ }
+ });
+
  describe('init()', () => {
  test('calls Sentry.init with correct sdk info metadata', () => {
  Sentry.AWSLambda.init({});

packages/serverless/test/gcpfunction.test.ts

@@ -1,4 +1,5 @@
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 import * as domain from 'domain';
 
 import * as Sentry from '../src';
@@ -12,7 +13,6 @@ import type {
  Request,
  Response,
 } from '../src/gcpfunction/general';
-
 /**
  * Why @ts-ignore some Sentry.X calls
  *
@@ -198,7 +198,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -317,7 +317,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -382,7 +382,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -440,7 +440,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -469,7 +469,33 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ });
+ });
+
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(4);
+
+ const error = new Error('wat');
+ const handler: EventFunctionWithCallback = (_data, _context, _cb) => {
+ throw error;
+ };
+ const wrappedHandler = wrapEventFunction(handler);
+ await expect(handleEvent(wrappedHandler)).rejects.toThrowError(error);
+
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+
+ // @ts-ignore just mocking around...
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
  });
  });
 
@@ -537,7 +563,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -595,7 +621,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -625,7 +651,7 @@ describe('GCPFunction', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
 
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  });
  });
 

packages/serverless/src/awslambda.ts

@@ -14,7 +14,7 @@ import { performance } from 'perf_hooks';
 import { types } from 'util';
 
 import { AWSServices } from './awsservices';
-import { serverlessEventProcessor } from './utils';
+import { markEventUnhandled, serverlessEventProcessor } from './utils';
 
 export * from '@sentry/node';
 
@@ -312,11 +312,11 @@ export function wrapHandler<TEvent, TResult>(
  if (options.captureAllSettledReasons && Array.isArray(rv) && isPromiseAllSettledResult(rv)) {
  const reasons = getRejectedReasons(rv);
  reasons.forEach(exception => {
- captureException(exception);
+ captureException(exception, scope => markEventUnhandled(scope));
  });
  }
  } catch (e) {
- captureException(e);
+ captureException(e, scope => markEventUnhandled(scope));
  throw e;
  } finally {
  clearTimeout(timeoutWarningTimer);

packages/serverless/src/gcpfunction/cloud_events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { CloudEventFunction, CloudEventFunctionWithCallback, WrapperOptions } from './general';
 
 export type CloudEventFunctionWrapperOptions = WrapperOptions;
@@ -50,7 +50,7 @@ function _wrapCloudEventFunction(
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -68,13 +68,13 @@ function _wrapCloudEventFunction(
  try {
  fnResult = (fn as CloudEventFunctionWithCallback)(context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { EventFunction, EventFunctionWithCallback, WrapperOptions } from './general';
 
 export type EventFunctionWrapperOptions = WrapperOptions;
@@ -52,7 +52,7 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -72,13 +72,13 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
  try {
  fnResult = (fn as EventFunctionWithCallback)(data, context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/http.ts

@@ -2,7 +2,7 @@ import type { AddRequestDataToEventOptions } from '@sentry/node';
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isString, isThenable, logger, stripUrlQueryAndFragment, tracingContextFromHeaders } from '@sentry/utils';
 
-import { domainify, proxyFunction } from './../utils';
+import { domainify, markEventUnhandled, proxyFunction } from './../utils';
 import type { HttpFunction, WrapperOptions } from './general';
 
 // TODO (v8 / #5257): Remove this whole old/new business and just use the new stuff
@@ -122,13 +122,13 @@ function _wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<HttpFunctionWr
  try {
  fnResult = fn(req, res);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/utils.ts

@@ -1,5 +1,6 @@
 import { runWithAsyncContext } from '@sentry/core';
 import type { Event } from '@sentry/node';
+import type { Scope } from '@sentry/types';
 import { addExceptionMechanism } from '@sentry/utils';
 
 /**
@@ -55,3 +56,15 @@ export function proxyFunction<A extends any[], R, F extends (...args: A) => R>(
 
  return new Proxy(source, handler);
 }
+
+/**
+ * Marks an event as unhandled by adding a span processor to the passed scope.
+ */
+export function markEventUnhandled(scope: Scope): Scope {
+ scope.addEventProcessor(event => {
+ addExceptionMechanism(event, { handled: false });
+ return event;
+ });
+
+ return scope;
+}

packages/serverless/test/awslambda.test.ts

@@ -1,6 +1,7 @@
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 // eslint-disable-next-line import/no-unresolved
 import type { Callback, Handler } from 'aws-lambda';
 
@@ -175,8 +176,8 @@ describe('AWSLambda', () => {
  ]);
  const wrappedHandler = wrapHandler(handler, { flushTimeout: 1337, captureAllSettledReasons: true });
  await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2);
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error, expect.any(Function));
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2, expect.any(Function));
  expect(SentryNode.captureException).toBeCalledTimes(2);
  });
  });
@@ -229,7 +230,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalledWith(2000);
@@ -308,7 +309,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(e);
+ expect(SentryNode.captureException).toBeCalledWith(e, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -375,7 +376,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -457,14 +458,42 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
  }
  });
  });
 
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(3);
+
+ const error = new Error('wat');
+ const handler: Handler = async (_event, _context, _callback) => {
+ throw error;
+ };
+ const wrappedHandler = wrapHandler(handler);
+
+ try {
+ await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+ } catch (e) {
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ // @ts-ignore see "Why @ts-ignore" note
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
+ });
+ }
+ });
+
  describe('init()', () => {
  test('calls Sentry.init with correct sdk info metadata', () => {
  Sentry.AWSLambda.init({});

packages/serverless/test/gcpfunction.test.ts

@@ -1,4 +1,5 @@
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 import * as domain from 'domain';
 
 import * as Sentry from '../src';
@@ -12,7 +13,6 @@ import type {
  Request,
  Response,
 } from '../src/gcpfunction/general';
-
 /**
  * Why @ts-ignore some Sentry.X calls
  *
@@ -198,7 +198,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -317,7 +317,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -382,7 +382,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -440,7 +440,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -469,7 +469,33 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ });
+ });
+
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(4);
+
+ const error = new Error('wat');
+ const handler: EventFunctionWithCallback = (_data, _context, _cb) => {
+ throw error;
+ };
+ const wrappedHandler = wrapEventFunction(handler);
+ await expect(handleEvent(wrappedHandler)).rejects.toThrowError(error);
+
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+
+ // @ts-ignore just mocking around...
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
  });
  });
 
@@ -537,7 +563,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -595,7 +621,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -625,7 +651,7 @@ describe('GCPFunction', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
 
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  });
  });
 

packages/serverless/src/awslambda.ts

@@ -14,7 +14,7 @@ import { performance } from 'perf_hooks';
 import { types } from 'util';
 
 import { AWSServices } from './awsservices';
-import { serverlessEventProcessor } from './utils';
+import { markEventUnhandled, serverlessEventProcessor } from './utils';
 
 export * from '@sentry/node';
 
@@ -312,11 +312,11 @@ export function wrapHandler<TEvent, TResult>(
  if (options.captureAllSettledReasons && Array.isArray(rv) && isPromiseAllSettledResult(rv)) {
  const reasons = getRejectedReasons(rv);
  reasons.forEach(exception => {
- captureException(exception);
+ captureException(exception, scope => markEventUnhandled(scope));
  });
  }
  } catch (e) {
- captureException(e);
+ captureException(e, scope => markEventUnhandled(scope));
  throw e;
  } finally {
  clearTimeout(timeoutWarningTimer);

packages/serverless/src/gcpfunction/cloud_events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { CloudEventFunction, CloudEventFunctionWithCallback, WrapperOptions } from './general';
 
 export type CloudEventFunctionWrapperOptions = WrapperOptions;
@@ -50,7 +50,7 @@ function _wrapCloudEventFunction(
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -68,13 +68,13 @@ function _wrapCloudEventFunction(
  try {
  fnResult = (fn as CloudEventFunctionWithCallback)(context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { EventFunction, EventFunctionWithCallback, WrapperOptions } from './general';
 
 export type EventFunctionWrapperOptions = WrapperOptions;
@@ -52,7 +52,7 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -72,13 +72,13 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
  try {
  fnResult = (fn as EventFunctionWithCallback)(data, context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/http.ts

@@ -2,7 +2,7 @@ import type { AddRequestDataToEventOptions } from '@sentry/node';
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isString, isThenable, logger, stripUrlQueryAndFragment, tracingContextFromHeaders } from '@sentry/utils';
 
-import { domainify, proxyFunction } from './../utils';
+import { domainify, markEventUnhandled, proxyFunction } from './../utils';
 import type { HttpFunction, WrapperOptions } from './general';
 
 // TODO (v8 / #5257): Remove this whole old/new business and just use the new stuff
@@ -122,13 +122,13 @@ function _wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<HttpFunctionWr
  try {
  fnResult = fn(req, res);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/utils.ts

@@ -1,5 +1,6 @@
 import { runWithAsyncContext } from '@sentry/core';
 import type { Event } from '@sentry/node';
+import type { Scope } from '@sentry/types';
 import { addExceptionMechanism } from '@sentry/utils';
 
 /**
@@ -55,3 +56,15 @@ export function proxyFunction<A extends any[], R, F extends (...args: A) => R>(
 
  return new Proxy(source, handler);
 }
+
+/**
+ * Marks an event as unhandled by adding a span processor to the passed scope.
+ */
+export function markEventUnhandled(scope: Scope): Scope {
+ scope.addEventProcessor(event => {
+ addExceptionMechanism(event, { handled: false });
+ return event;
+ });
+
+ return scope;
+}

packages/serverless/test/awslambda.test.ts

@@ -1,6 +1,7 @@
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 // eslint-disable-next-line import/no-unresolved
 import type { Callback, Handler } from 'aws-lambda';
 
@@ -175,8 +176,8 @@ describe('AWSLambda', () => {
  ]);
  const wrappedHandler = wrapHandler(handler, { flushTimeout: 1337, captureAllSettledReasons: true });
  await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2);
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error, expect.any(Function));
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2, expect.any(Function));
  expect(SentryNode.captureException).toBeCalledTimes(2);
  });
  });
@@ -229,7 +230,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalledWith(2000);
@@ -308,7 +309,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(e);
+ expect(SentryNode.captureException).toBeCalledWith(e, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -375,7 +376,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -457,14 +458,42 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
  }
  });
  });
 
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(3);
+
+ const error = new Error('wat');
+ const handler: Handler = async (_event, _context, _callback) => {
+ throw error;
+ };
+ const wrappedHandler = wrapHandler(handler);
+
+ try {
+ await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+ } catch (e) {
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ // @ts-ignore see "Why @ts-ignore" note
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
+ });
+ }
+ });
+
  describe('init()', () => {
  test('calls Sentry.init with correct sdk info metadata', () => {
  Sentry.AWSLambda.init({});

packages/serverless/test/gcpfunction.test.ts

@@ -1,4 +1,5 @@
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 import * as domain from 'domain';
 
 import * as Sentry from '../src';
@@ -12,7 +13,6 @@ import type {
  Request,
  Response,
 } from '../src/gcpfunction/general';
-
 /**
  * Why @ts-ignore some Sentry.X calls
  *
@@ -198,7 +198,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -317,7 +317,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -382,7 +382,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -440,7 +440,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -469,7 +469,33 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ });
+ });
+
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(4);
+
+ const error = new Error('wat');
+ const handler: EventFunctionWithCallback = (_data, _context, _cb) => {
+ throw error;
+ };
+ const wrappedHandler = wrapEventFunction(handler);
+ await expect(handleEvent(wrappedHandler)).rejects.toThrowError(error);
+
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+
+ // @ts-ignore just mocking around...
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
  });
  });
 
@@ -537,7 +563,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -595,7 +621,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -625,7 +651,7 @@ describe('GCPFunction', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
 
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  });
  });
 

packages/serverless/src/awslambda.ts

@@ -14,7 +14,7 @@ import { performance } from 'perf_hooks';
 import { types } from 'util';
 
 import { AWSServices } from './awsservices';
-import { serverlessEventProcessor } from './utils';
+import { markEventUnhandled, serverlessEventProcessor } from './utils';
 
 export * from '@sentry/node';
 
@@ -312,11 +312,11 @@ export function wrapHandler<TEvent, TResult>(
  if (options.captureAllSettledReasons && Array.isArray(rv) && isPromiseAllSettledResult(rv)) {
  const reasons = getRejectedReasons(rv);
  reasons.forEach(exception => {
- captureException(exception);
+ captureException(exception, scope => markEventUnhandled(scope));
  });
  }
  } catch (e) {
- captureException(e);
+ captureException(e, scope => markEventUnhandled(scope));
  throw e;
  } finally {
  clearTimeout(timeoutWarningTimer);

packages/serverless/src/gcpfunction/cloud_events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { CloudEventFunction, CloudEventFunctionWithCallback, WrapperOptions } from './general';
 
 export type CloudEventFunctionWrapperOptions = WrapperOptions;
@@ -50,7 +50,7 @@ function _wrapCloudEventFunction(
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -68,13 +68,13 @@ function _wrapCloudEventFunction(
  try {
  fnResult = (fn as CloudEventFunctionWithCallback)(context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { EventFunction, EventFunctionWithCallback, WrapperOptions } from './general';
 
 export type EventFunctionWrapperOptions = WrapperOptions;
@@ -52,7 +52,7 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -72,13 +72,13 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
  try {
  fnResult = (fn as EventFunctionWithCallback)(data, context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/http.ts

@@ -2,7 +2,7 @@ import type { AddRequestDataToEventOptions } from '@sentry/node';
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isString, isThenable, logger, stripUrlQueryAndFragment, tracingContextFromHeaders } from '@sentry/utils';
 
-import { domainify, proxyFunction } from './../utils';
+import { domainify, markEventUnhandled, proxyFunction } from './../utils';
 import type { HttpFunction, WrapperOptions } from './general';
 
 // TODO (v8 / #5257): Remove this whole old/new business and just use the new stuff
@@ -122,13 +122,13 @@ function _wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<HttpFunctionWr
  try {
  fnResult = fn(req, res);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/utils.ts

@@ -1,5 +1,6 @@
 import { runWithAsyncContext } from '@sentry/core';
 import type { Event } from '@sentry/node';
+import type { Scope } from '@sentry/types';
 import { addExceptionMechanism } from '@sentry/utils';
 
 /**
@@ -55,3 +56,15 @@ export function proxyFunction<A extends any[], R, F extends (...args: A) => R>(
 
  return new Proxy(source, handler);
 }
+
+/**
+ * Marks an event as unhandled by adding a span processor to the passed scope.
+ */
+export function markEventUnhandled(scope: Scope): Scope {
+ scope.addEventProcessor(event => {
+ addExceptionMechanism(event, { handled: false });
+ return event;
+ });
+
+ return scope;
+}

packages/serverless/test/awslambda.test.ts

@@ -1,6 +1,7 @@
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 // eslint-disable-next-line import/no-unresolved
 import type { Callback, Handler } from 'aws-lambda';
 
@@ -175,8 +176,8 @@ describe('AWSLambda', () => {
  ]);
  const wrappedHandler = wrapHandler(handler, { flushTimeout: 1337, captureAllSettledReasons: true });
  await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2);
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error, expect.any(Function));
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2, expect.any(Function));
  expect(SentryNode.captureException).toBeCalledTimes(2);
  });
  });
@@ -229,7 +230,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalledWith(2000);
@@ -308,7 +309,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(e);
+ expect(SentryNode.captureException).toBeCalledWith(e, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -375,7 +376,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -457,14 +458,42 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
  }
  });
  });
 
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(3);
+
+ const error = new Error('wat');
+ const handler: Handler = async (_event, _context, _callback) => {
+ throw error;
+ };
+ const wrappedHandler = wrapHandler(handler);
+
+ try {
+ await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+ } catch (e) {
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ // @ts-ignore see "Why @ts-ignore" note
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
+ });
+ }
+ });
+
  describe('init()', () => {
  test('calls Sentry.init with correct sdk info metadata', () => {
  Sentry.AWSLambda.init({});

packages/serverless/test/gcpfunction.test.ts

@@ -1,4 +1,5 @@
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 import * as domain from 'domain';
 
 import * as Sentry from '../src';
@@ -12,7 +13,6 @@ import type {
  Request,
  Response,
 } from '../src/gcpfunction/general';
-
 /**
  * Why @ts-ignore some Sentry.X calls
  *
@@ -198,7 +198,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -317,7 +317,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -382,7 +382,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -440,7 +440,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -469,7 +469,33 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ });
+ });
+
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(4);
+
+ const error = new Error('wat');
+ const handler: EventFunctionWithCallback = (_data, _context, _cb) => {
+ throw error;
+ };
+ const wrappedHandler = wrapEventFunction(handler);
+ await expect(handleEvent(wrappedHandler)).rejects.toThrowError(error);
+
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+
+ // @ts-ignore just mocking around...
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
  });
  });
 
@@ -537,7 +563,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -595,7 +621,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -625,7 +651,7 @@ describe('GCPFunction', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
 
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  });
  });
 

packages/serverless/src/awslambda.ts

@@ -14,7 +14,7 @@ import { performance } from 'perf_hooks';
 import { types } from 'util';
 
 import { AWSServices } from './awsservices';
-import { serverlessEventProcessor } from './utils';
+import { markEventUnhandled, serverlessEventProcessor } from './utils';
 
 export * from '@sentry/node';
 
@@ -312,11 +312,11 @@ export function wrapHandler<TEvent, TResult>(
  if (options.captureAllSettledReasons && Array.isArray(rv) && isPromiseAllSettledResult(rv)) {
  const reasons = getRejectedReasons(rv);
  reasons.forEach(exception => {
- captureException(exception);
+ captureException(exception, scope => markEventUnhandled(scope));
  });
  }
  } catch (e) {
- captureException(e);
+ captureException(e, scope => markEventUnhandled(scope));
  throw e;
  } finally {
  clearTimeout(timeoutWarningTimer);

packages/serverless/src/gcpfunction/cloud_events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { CloudEventFunction, CloudEventFunctionWithCallback, WrapperOptions } from './general';
 
 export type CloudEventFunctionWrapperOptions = WrapperOptions;
@@ -50,7 +50,7 @@ function _wrapCloudEventFunction(
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -68,13 +68,13 @@ function _wrapCloudEventFunction(
  try {
  fnResult = (fn as CloudEventFunctionWithCallback)(context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { EventFunction, EventFunctionWithCallback, WrapperOptions } from './general';
 
 export type EventFunctionWrapperOptions = WrapperOptions;
@@ -52,7 +52,7 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -72,13 +72,13 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
  try {
  fnResult = (fn as EventFunctionWithCallback)(data, context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/http.ts

@@ -2,7 +2,7 @@ import type { AddRequestDataToEventOptions } from '@sentry/node';
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isString, isThenable, logger, stripUrlQueryAndFragment, tracingContextFromHeaders } from '@sentry/utils';
 
-import { domainify, proxyFunction } from './../utils';
+import { domainify, markEventUnhandled, proxyFunction } from './../utils';
 import type { HttpFunction, WrapperOptions } from './general';
 
 // TODO (v8 / #5257): Remove this whole old/new business and just use the new stuff
@@ -122,13 +122,13 @@ function _wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<HttpFunctionWr
  try {
  fnResult = fn(req, res);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/utils.ts

@@ -1,5 +1,6 @@
 import { runWithAsyncContext } from '@sentry/core';
 import type { Event } from '@sentry/node';
+import type { Scope } from '@sentry/types';
 import { addExceptionMechanism } from '@sentry/utils';
 
 /**
@@ -55,3 +56,15 @@ export function proxyFunction<A extends any[], R, F extends (...args: A) => R>(
 
  return new Proxy(source, handler);
 }
+
+/**
+ * Marks an event as unhandled by adding a span processor to the passed scope.
+ */
+export function markEventUnhandled(scope: Scope): Scope {
+ scope.addEventProcessor(event => {
+ addExceptionMechanism(event, { handled: false });
+ return event;
+ });
+
+ return scope;
+}

packages/serverless/test/awslambda.test.ts

@@ -1,6 +1,7 @@
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 // eslint-disable-next-line import/no-unresolved
 import type { Callback, Handler } from 'aws-lambda';
 
@@ -175,8 +176,8 @@ describe('AWSLambda', () => {
  ]);
  const wrappedHandler = wrapHandler(handler, { flushTimeout: 1337, captureAllSettledReasons: true });
  await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2);
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error, expect.any(Function));
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2, expect.any(Function));
  expect(SentryNode.captureException).toBeCalledTimes(2);
  });
  });
@@ -229,7 +230,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalledWith(2000);
@@ -308,7 +309,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(e);
+ expect(SentryNode.captureException).toBeCalledWith(e, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -375,7 +376,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -457,14 +458,42 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
  }
  });
  });
 
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(3);
+
+ const error = new Error('wat');
+ const handler: Handler = async (_event, _context, _callback) => {
+ throw error;
+ };
+ const wrappedHandler = wrapHandler(handler);
+
+ try {
+ await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+ } catch (e) {
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ // @ts-ignore see "Why @ts-ignore" note
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
+ });
+ }
+ });
+
  describe('init()', () => {
  test('calls Sentry.init with correct sdk info metadata', () => {
  Sentry.AWSLambda.init({});

packages/serverless/test/gcpfunction.test.ts

@@ -1,4 +1,5 @@
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 import * as domain from 'domain';
 
 import * as Sentry from '../src';
@@ -12,7 +13,6 @@ import type {
  Request,
  Response,
 } from '../src/gcpfunction/general';
-
 /**
  * Why @ts-ignore some Sentry.X calls
  *
@@ -198,7 +198,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -317,7 +317,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -382,7 +382,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -440,7 +440,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -469,7 +469,33 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ });
+ });
+
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(4);
+
+ const error = new Error('wat');
+ const handler: EventFunctionWithCallback = (_data, _context, _cb) => {
+ throw error;
+ };
+ const wrappedHandler = wrapEventFunction(handler);
+ await expect(handleEvent(wrappedHandler)).rejects.toThrowError(error);
+
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+
+ // @ts-ignore just mocking around...
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
  });
  });
 
@@ -537,7 +563,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -595,7 +621,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -625,7 +651,7 @@ describe('GCPFunction', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
 
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  });
  });
 

packages/serverless/src/awslambda.ts

@@ -14,7 +14,7 @@ import { performance } from 'perf_hooks';
 import { types } from 'util';
 
 import { AWSServices } from './awsservices';
-import { serverlessEventProcessor } from './utils';
+import { markEventUnhandled, serverlessEventProcessor } from './utils';
 
 export * from '@sentry/node';
 
@@ -312,11 +312,11 @@ export function wrapHandler<TEvent, TResult>(
  if (options.captureAllSettledReasons && Array.isArray(rv) && isPromiseAllSettledResult(rv)) {
  const reasons = getRejectedReasons(rv);
  reasons.forEach(exception => {
- captureException(exception);
+ captureException(exception, scope => markEventUnhandled(scope));
  });
  }
  } catch (e) {
- captureException(e);
+ captureException(e, scope => markEventUnhandled(scope));
  throw e;
  } finally {
  clearTimeout(timeoutWarningTimer);

packages/serverless/src/gcpfunction/cloud_events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { CloudEventFunction, CloudEventFunctionWithCallback, WrapperOptions } from './general';
 
 export type CloudEventFunctionWrapperOptions = WrapperOptions;
@@ -50,7 +50,7 @@ function _wrapCloudEventFunction(
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -68,13 +68,13 @@ function _wrapCloudEventFunction(
  try {
  fnResult = (fn as CloudEventFunctionWithCallback)(context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { EventFunction, EventFunctionWithCallback, WrapperOptions } from './general';
 
 export type EventFunctionWrapperOptions = WrapperOptions;
@@ -52,7 +52,7 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -72,13 +72,13 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
  try {
  fnResult = (fn as EventFunctionWithCallback)(data, context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/http.ts

@@ -2,7 +2,7 @@ import type { AddRequestDataToEventOptions } from '@sentry/node';
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isString, isThenable, logger, stripUrlQueryAndFragment, tracingContextFromHeaders } from '@sentry/utils';
 
-import { domainify, proxyFunction } from './../utils';
+import { domainify, markEventUnhandled, proxyFunction } from './../utils';
 import type { HttpFunction, WrapperOptions } from './general';
 
 // TODO (v8 / #5257): Remove this whole old/new business and just use the new stuff
@@ -122,13 +122,13 @@ function _wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<HttpFunctionWr
  try {
  fnResult = fn(req, res);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/utils.ts

@@ -1,5 +1,6 @@
 import { runWithAsyncContext } from '@sentry/core';
 import type { Event } from '@sentry/node';
+import type { Scope } from '@sentry/types';
 import { addExceptionMechanism } from '@sentry/utils';
 
 /**
@@ -55,3 +56,15 @@ export function proxyFunction<A extends any[], R, F extends (...args: A) => R>(
 
  return new Proxy(source, handler);
 }
+
+/**
+ * Marks an event as unhandled by adding a span processor to the passed scope.
+ */
+export function markEventUnhandled(scope: Scope): Scope {
+ scope.addEventProcessor(event => {
+ addExceptionMechanism(event, { handled: false });
+ return event;
+ });
+
+ return scope;
+}

packages/serverless/test/awslambda.test.ts

@@ -1,6 +1,7 @@
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 // eslint-disable-next-line import/no-unresolved
 import type { Callback, Handler } from 'aws-lambda';
 
@@ -175,8 +176,8 @@ describe('AWSLambda', () => {
  ]);
  const wrappedHandler = wrapHandler(handler, { flushTimeout: 1337, captureAllSettledReasons: true });
  await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2);
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error, expect.any(Function));
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2, expect.any(Function));
  expect(SentryNode.captureException).toBeCalledTimes(2);
  });
  });
@@ -229,7 +230,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalledWith(2000);
@@ -308,7 +309,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(e);
+ expect(SentryNode.captureException).toBeCalledWith(e, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -375,7 +376,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -457,14 +458,42 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
  }
  });
  });
 
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(3);
+
+ const error = new Error('wat');
+ const handler: Handler = async (_event, _context, _callback) => {
+ throw error;
+ };
+ const wrappedHandler = wrapHandler(handler);
+
+ try {
+ await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+ } catch (e) {
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ // @ts-ignore see "Why @ts-ignore" note
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
+ });
+ }
+ });
+
  describe('init()', () => {
  test('calls Sentry.init with correct sdk info metadata', () => {
  Sentry.AWSLambda.init({});

packages/serverless/test/gcpfunction.test.ts

@@ -1,4 +1,5 @@
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 import * as domain from 'domain';
 
 import * as Sentry from '../src';
@@ -12,7 +13,6 @@ import type {
  Request,
  Response,
 } from '../src/gcpfunction/general';
-
 /**
  * Why @ts-ignore some Sentry.X calls
  *
@@ -198,7 +198,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -317,7 +317,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -382,7 +382,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -440,7 +440,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -469,7 +469,33 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ });
+ });
+
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(4);
+
+ const error = new Error('wat');
+ const handler: EventFunctionWithCallback = (_data, _context, _cb) => {
+ throw error;
+ };
+ const wrappedHandler = wrapEventFunction(handler);
+ await expect(handleEvent(wrappedHandler)).rejects.toThrowError(error);
+
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+
+ // @ts-ignore just mocking around...
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
  });
  });
 
@@ -537,7 +563,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -595,7 +621,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -625,7 +651,7 @@ describe('GCPFunction', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
 
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  });
  });
 

packages/serverless/src/awslambda.ts

@@ -14,7 +14,7 @@ import { performance } from 'perf_hooks';
 import { types } from 'util';
 
 import { AWSServices } from './awsservices';
-import { serverlessEventProcessor } from './utils';
+import { markEventUnhandled, serverlessEventProcessor } from './utils';
 
 export * from '@sentry/node';
 
@@ -312,11 +312,11 @@ export function wrapHandler<TEvent, TResult>(
  if (options.captureAllSettledReasons && Array.isArray(rv) && isPromiseAllSettledResult(rv)) {
  const reasons = getRejectedReasons(rv);
  reasons.forEach(exception => {
- captureException(exception);
+ captureException(exception, scope => markEventUnhandled(scope));
  });
  }
  } catch (e) {
- captureException(e);
+ captureException(e, scope => markEventUnhandled(scope));
  throw e;
  } finally {
  clearTimeout(timeoutWarningTimer);

packages/serverless/src/gcpfunction/cloud_events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { CloudEventFunction, CloudEventFunctionWithCallback, WrapperOptions } from './general';
 
 export type CloudEventFunctionWrapperOptions = WrapperOptions;
@@ -50,7 +50,7 @@ function _wrapCloudEventFunction(
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -68,13 +68,13 @@ function _wrapCloudEventFunction(
  try {
  fnResult = (fn as CloudEventFunctionWithCallback)(context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/events.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isThenable, logger } from '@sentry/utils';
 
-import { domainify, proxyFunction } from '../utils';
+import { domainify, markEventUnhandled, proxyFunction } from '../utils';
 import type { EventFunction, EventFunctionWithCallback, WrapperOptions } from './general';
 
 export type EventFunctionWrapperOptions = WrapperOptions;
@@ -52,7 +52,7 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
 
  const newCallback = domainify((...args: unknown[]) => {
  if (args[0] !== null && args[0] !== undefined) {
- captureException(args[0]);
+ captureException(args[0], scope => markEventUnhandled(scope));
  }
  transaction?.finish();
 
@@ -72,13 +72,13 @@ function _wrapEventFunction<F extends EventFunction | EventFunctionWithCallback>
  try {
  fnResult = (fn as EventFunctionWithCallback)(data, context, newCallback);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/gcpfunction/http.ts

@@ -2,7 +2,7 @@ import type { AddRequestDataToEventOptions } from '@sentry/node';
 import { captureException, flush, getCurrentHub } from '@sentry/node';
 import { isString, isThenable, logger, stripUrlQueryAndFragment, tracingContextFromHeaders } from '@sentry/utils';
 
-import { domainify, proxyFunction } from './../utils';
+import { domainify, markEventUnhandled, proxyFunction } from './../utils';
 import type { HttpFunction, WrapperOptions } from './general';
 
 // TODO (v8 / #5257): Remove this whole old/new business and just use the new stuff
@@ -122,13 +122,13 @@ function _wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<HttpFunctionWr
  try {
  fnResult = fn(req, res);
  } catch (err) {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  }
 
  if (isThenable(fnResult)) {
  fnResult.then(null, err => {
- captureException(err);
+ captureException(err, scope => markEventUnhandled(scope));
  throw err;
  });
  }

packages/serverless/src/utils.ts

@@ -1,5 +1,6 @@
 import { runWithAsyncContext } from '@sentry/core';
 import type { Event } from '@sentry/node';
+import type { Scope } from '@sentry/types';
 import { addExceptionMechanism } from '@sentry/utils';
 
 /**
@@ -55,3 +56,15 @@ export function proxyFunction<A extends any[], R, F extends (...args: A) => R>(
 
  return new Proxy(source, handler);
 }
+
+/**
+ * Marks an event as unhandled by adding a span processor to the passed scope.
+ */
+export function markEventUnhandled(scope: Scope): Scope {
+ scope.addEventProcessor(event => {
+ addExceptionMechanism(event, { handled: false });
+ return event;
+ });
+
+ return scope;
+}

packages/serverless/test/awslambda.test.ts

@@ -1,6 +1,7 @@
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 // eslint-disable-next-line import/no-unresolved
 import type { Callback, Handler } from 'aws-lambda';
 
@@ -175,8 +176,8 @@ describe('AWSLambda', () => {
  ]);
  const wrappedHandler = wrapHandler(handler, { flushTimeout: 1337, captureAllSettledReasons: true });
  await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error);
- expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2);
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(1, error, expect.any(Function));
+ expect(SentryNode.captureException).toHaveBeenNthCalledWith(2, error2, expect.any(Function));
  expect(SentryNode.captureException).toBeCalledTimes(2);
  });
  });
@@ -229,7 +230,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalledWith(2000);
@@ -308,7 +309,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(e);
+ expect(SentryNode.captureException).toBeCalledWith(e, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -375,7 +376,7 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -457,14 +458,42 @@ describe('AWSLambda', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  expectScopeSettings(fakeTransactionContext);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
  }
  });
  });
 
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(3);
+
+ const error = new Error('wat');
+ const handler: Handler = async (_event, _context, _callback) => {
+ throw error;
+ };
+ const wrappedHandler = wrapHandler(handler);
+
+ try {
+ await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+ } catch (e) {
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ // @ts-ignore see "Why @ts-ignore" note
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
+ });
+ }
+ });
+
  describe('init()', () => {
  test('calls Sentry.init with correct sdk info metadata', () => {
  Sentry.AWSLambda.init({});

packages/serverless/test/gcpfunction.test.ts

@@ -1,4 +1,5 @@
 import * as SentryNode from '@sentry/node';
+import type { Event } from '@sentry/types';
 import * as domain from 'domain';
 
 import * as Sentry from '../src';
@@ -12,7 +13,6 @@ import type {
  Request,
  Response,
 } from '../src/gcpfunction/general';
-
 /**
  * Why @ts-ignore some Sentry.X calls
  *
@@ -198,7 +198,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -317,7 +317,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -382,7 +382,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -440,7 +440,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -469,7 +469,33 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+ });
+ });
+
+ test('marks the captured error as unhandled', async () => {
+ expect.assertions(4);
+
+ const error = new Error('wat');
+ const handler: EventFunctionWithCallback = (_data, _context, _cb) => {
+ throw error;
+ };
+ const wrappedHandler = wrapEventFunction(handler);
+ await expect(handleEvent(wrappedHandler)).rejects.toThrowError(error);
+
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
+
+ // @ts-ignore just mocking around...
+ const scopeFunction = SentryNode.captureException.mock.calls[0][1];
+ const event: Event = { exception: { values: [{}] } };
+ let evtProcessor: ((e: Event) => Event) | undefined = undefined;
+ scopeFunction({ addEventProcessor: jest.fn().mockImplementation(proc => (evtProcessor = proc)) });
+
+ expect(evtProcessor).toBeInstanceOf(Function);
+ // @ts-ignore just mocking around...
+ expect(evtProcessor(event).exception.values[0].mechanism).toEqual({
+ handled: false,
+ type: 'generic',
  });
  });
 
@@ -537,7 +563,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -595,7 +621,7 @@ describe('GCPFunction', () => {
  expect(SentryNode.fakeHub.startTransaction).toBeCalledWith(fakeTransactionContext);
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeTransaction.finish).toBeCalled();
  expect(SentryNode.flush).toBeCalled();
@@ -625,7 +651,7 @@ describe('GCPFunction', () => {
  // @ts-ignore see "Why @ts-ignore" note
  expect(SentryNode.fakeScope.setSpan).toBeCalledWith(fakeTransaction);
 
- expect(SentryNode.captureException).toBeCalledWith(error);
+ expect(SentryNode.captureException).toBeCalledWith(error, expect.any(Function));
  });
  });