feat(core): Use the ignoreErrors logic for failed transactions

packages/core/src/tracing/errors.ts

@@ -1,12 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import {
  addGlobalErrorInstrumentationHandler,
  addGlobalUnhandledRejectionInstrumentationHandler,
  logger,
+ stringMatchesSomePattern,
 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { getActiveSpan, getRootSpan } from '../utils/spanUtils';
+import { getClient } from '../currentScopes';
 import { SPAN_STATUS_ERROR } from './spanstatus';
+import { type HandlerDataError } from '@sentry/types';
 
 let errorsInstrumented = false;
 
@@ -31,16 +36,45 @@ export function registerSpanErrorInstrumentation(): void {
 /**
  * If an error or unhandled promise occurs, we mark the active root span as failed
  */
-function errorCallback(): void {
+function errorCallback(error: any): void {
  const activeSpan = getActiveSpan();
  const rootSpan = activeSpan && getRootSpan(activeSpan);
  if (rootSpan) {
+ if (_isIgnoredError(error)) {
+ DEBUG_BUILD && logger.log('[Tracing] Root span: Global error occured then ignored');
+ return;
+ }
+
  const message = 'internal_error';
  DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occured`);
  rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });
  }
 }
 
+function _isIgnoredError(error: any): boolean {
+ if (!error) {
+ return false;
+ }
+
+ const errorMessage = _errorMessage(error);
+
+ const client = getClient();
+ if (!client) {
+ return false;
+ }
+
+ const options = client.getOptions();
+ if (!options) {
+ return false;
+ }
+
+ return stringMatchesSomePattern(errorMessage, options.ignoreErrors);
+}
+
+function _errorMessage(error: any): string {
+ return String((error as HandlerDataError).msg || (error as Error).message || error);
+}
+
 // The function name will be lost when bundling but we need to be able to identify this listener later to maintain the
 // node.js default exit behaviour
 errorCallback.tag = 'sentry_tracingErrorCallback';

packages/core/test/lib/tracing/errors.test.ts

@@ -29,7 +29,10 @@ describe('registerErrorHandlers()', () => {
  beforeEach(() => {
  mockAddGlobalErrorInstrumentationHandler.mockClear();
  mockAddGlobalUnhandledRejectionInstrumentationHandler.mockClear();
- const options = getDefaultTestClientOptions({ enableTracing: true });
+ const options = getDefaultTestClientOptions({
+ enableTracing: true,
+ ignoreErrors: ['entity not found', /some error that will not happen.*/],
+ });
  const client = new TestClient(options);
  setCurrentClient(client);
  client.init();
@@ -76,4 +79,22 @@ describe('registerErrorHandlers()', () => {
  expect(spanToJSON(span).status).toBe('internal_error');
  });
  });
+
+ it('does not set status for transaction on scope on an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockErrorCallback({ msg: 'Database entity not found!' });
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
+
+ it('does not set status for transaction on scope on unhandledrejection for an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockUnhandledRejectionCallback('Database entity not found!');
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
 });

packages/core/src/tracing/errors.ts

@@ -1,12 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import {
  addGlobalErrorInstrumentationHandler,
  addGlobalUnhandledRejectionInstrumentationHandler,
  logger,
+ stringMatchesSomePattern,
 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { getActiveSpan, getRootSpan } from '../utils/spanUtils';
+import { getClient } from '../currentScopes';
 import { SPAN_STATUS_ERROR } from './spanstatus';
+import { type HandlerDataError } from '@sentry/types';
 
 let errorsInstrumented = false;
 
@@ -31,16 +36,45 @@ export function registerSpanErrorInstrumentation(): void {
 /**
  * If an error or unhandled promise occurs, we mark the active root span as failed
  */
-function errorCallback(): void {
+function errorCallback(error: any): void {
  const activeSpan = getActiveSpan();
  const rootSpan = activeSpan && getRootSpan(activeSpan);
  if (rootSpan) {
+ if (_isIgnoredError(error)) {
+ DEBUG_BUILD && logger.log('[Tracing] Root span: Global error occured then ignored');
+ return;
+ }
+
  const message = 'internal_error';
  DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occured`);
  rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });
  }
 }
 
+function _isIgnoredError(error: any): boolean {
+ if (!error) {
+ return false;
+ }
+
+ const errorMessage = _errorMessage(error);
+
+ const client = getClient();
+ if (!client) {
+ return false;
+ }
+
+ const options = client.getOptions();
+ if (!options) {
+ return false;
+ }
+
+ return stringMatchesSomePattern(errorMessage, options.ignoreErrors);
+}
+
+function _errorMessage(error: any): string {
+ return String((error as HandlerDataError).msg || (error as Error).message || error);
+}
+
 // The function name will be lost when bundling but we need to be able to identify this listener later to maintain the
 // node.js default exit behaviour
 errorCallback.tag = 'sentry_tracingErrorCallback';

packages/core/test/lib/tracing/errors.test.ts

@@ -29,7 +29,10 @@ describe('registerErrorHandlers()', () => {
  beforeEach(() => {
  mockAddGlobalErrorInstrumentationHandler.mockClear();
  mockAddGlobalUnhandledRejectionInstrumentationHandler.mockClear();
- const options = getDefaultTestClientOptions({ enableTracing: true });
+ const options = getDefaultTestClientOptions({
+ enableTracing: true,
+ ignoreErrors: ['entity not found', /some error that will not happen.*/],
+ });
  const client = new TestClient(options);
  setCurrentClient(client);
  client.init();
@@ -76,4 +79,22 @@ describe('registerErrorHandlers()', () => {
  expect(spanToJSON(span).status).toBe('internal_error');
  });
  });
+
+ it('does not set status for transaction on scope on an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockErrorCallback({ msg: 'Database entity not found!' });
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
+
+ it('does not set status for transaction on scope on unhandledrejection for an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockUnhandledRejectionCallback('Database entity not found!');
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
 });

packages/core/src/tracing/errors.ts

@@ -1,12 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import {
  addGlobalErrorInstrumentationHandler,
  addGlobalUnhandledRejectionInstrumentationHandler,
  logger,
+ stringMatchesSomePattern,
 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { getActiveSpan, getRootSpan } from '../utils/spanUtils';
+import { getClient } from '../currentScopes';
 import { SPAN_STATUS_ERROR } from './spanstatus';
+import { type HandlerDataError } from '@sentry/types';
 
 let errorsInstrumented = false;
 
@@ -31,16 +36,45 @@ export function registerSpanErrorInstrumentation(): void {
 /**
  * If an error or unhandled promise occurs, we mark the active root span as failed
  */
-function errorCallback(): void {
+function errorCallback(error: any): void {
  const activeSpan = getActiveSpan();
  const rootSpan = activeSpan && getRootSpan(activeSpan);
  if (rootSpan) {
+ if (_isIgnoredError(error)) {
+ DEBUG_BUILD && logger.log('[Tracing] Root span: Global error occured then ignored');
+ return;
+ }
+
  const message = 'internal_error';
  DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occured`);
  rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });
  }
 }
 
+function _isIgnoredError(error: any): boolean {
+ if (!error) {
+ return false;
+ }
+
+ const errorMessage = _errorMessage(error);
+
+ const client = getClient();
+ if (!client) {
+ return false;
+ }
+
+ const options = client.getOptions();
+ if (!options) {
+ return false;
+ }
+
+ return stringMatchesSomePattern(errorMessage, options.ignoreErrors);
+}
+
+function _errorMessage(error: any): string {
+ return String((error as HandlerDataError).msg || (error as Error).message || error);
+}
+
 // The function name will be lost when bundling but we need to be able to identify this listener later to maintain the
 // node.js default exit behaviour
 errorCallback.tag = 'sentry_tracingErrorCallback';

packages/core/test/lib/tracing/errors.test.ts

@@ -29,7 +29,10 @@ describe('registerErrorHandlers()', () => {
  beforeEach(() => {
  mockAddGlobalErrorInstrumentationHandler.mockClear();
  mockAddGlobalUnhandledRejectionInstrumentationHandler.mockClear();
- const options = getDefaultTestClientOptions({ enableTracing: true });
+ const options = getDefaultTestClientOptions({
+ enableTracing: true,
+ ignoreErrors: ['entity not found', /some error that will not happen.*/],
+ });
  const client = new TestClient(options);
  setCurrentClient(client);
  client.init();
@@ -76,4 +79,22 @@ describe('registerErrorHandlers()', () => {
  expect(spanToJSON(span).status).toBe('internal_error');
  });
  });
+
+ it('does not set status for transaction on scope on an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockErrorCallback({ msg: 'Database entity not found!' });
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
+
+ it('does not set status for transaction on scope on unhandledrejection for an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockUnhandledRejectionCallback('Database entity not found!');
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
 });

packages/core/src/tracing/errors.ts

@@ -1,12 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import {
  addGlobalErrorInstrumentationHandler,
  addGlobalUnhandledRejectionInstrumentationHandler,
  logger,
+ stringMatchesSomePattern,
 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { getActiveSpan, getRootSpan } from '../utils/spanUtils';
+import { getClient } from '../currentScopes';
 import { SPAN_STATUS_ERROR } from './spanstatus';
+import { type HandlerDataError } from '@sentry/types';
 
 let errorsInstrumented = false;
 
@@ -31,16 +36,45 @@ export function registerSpanErrorInstrumentation(): void {
 /**
  * If an error or unhandled promise occurs, we mark the active root span as failed
  */
-function errorCallback(): void {
+function errorCallback(error: any): void {
  const activeSpan = getActiveSpan();
  const rootSpan = activeSpan && getRootSpan(activeSpan);
  if (rootSpan) {
+ if (_isIgnoredError(error)) {
+ DEBUG_BUILD && logger.log('[Tracing] Root span: Global error occured then ignored');
+ return;
+ }
+
  const message = 'internal_error';
  DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occured`);
  rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });
  }
 }
 
+function _isIgnoredError(error: any): boolean {
+ if (!error) {
+ return false;
+ }
+
+ const errorMessage = _errorMessage(error);
+
+ const client = getClient();
+ if (!client) {
+ return false;
+ }
+
+ const options = client.getOptions();
+ if (!options) {
+ return false;
+ }
+
+ return stringMatchesSomePattern(errorMessage, options.ignoreErrors);
+}
+
+function _errorMessage(error: any): string {
+ return String((error as HandlerDataError).msg || (error as Error).message || error);
+}
+
 // The function name will be lost when bundling but we need to be able to identify this listener later to maintain the
 // node.js default exit behaviour
 errorCallback.tag = 'sentry_tracingErrorCallback';

packages/core/test/lib/tracing/errors.test.ts

@@ -29,7 +29,10 @@ describe('registerErrorHandlers()', () => {
  beforeEach(() => {
  mockAddGlobalErrorInstrumentationHandler.mockClear();
  mockAddGlobalUnhandledRejectionInstrumentationHandler.mockClear();
- const options = getDefaultTestClientOptions({ enableTracing: true });
+ const options = getDefaultTestClientOptions({
+ enableTracing: true,
+ ignoreErrors: ['entity not found', /some error that will not happen.*/],
+ });
  const client = new TestClient(options);
  setCurrentClient(client);
  client.init();
@@ -76,4 +79,22 @@ describe('registerErrorHandlers()', () => {
  expect(spanToJSON(span).status).toBe('internal_error');
  });
  });
+
+ it('does not set status for transaction on scope on an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockErrorCallback({ msg: 'Database entity not found!' });
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
+
+ it('does not set status for transaction on scope on unhandledrejection for an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockUnhandledRejectionCallback('Database entity not found!');
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
 });

packages/core/src/tracing/errors.ts

@@ -1,12 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import {
  addGlobalErrorInstrumentationHandler,
  addGlobalUnhandledRejectionInstrumentationHandler,
  logger,
+ stringMatchesSomePattern,
 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { getActiveSpan, getRootSpan } from '../utils/spanUtils';
+import { getClient } from '../currentScopes';
 import { SPAN_STATUS_ERROR } from './spanstatus';
+import { type HandlerDataError } from '@sentry/types';
 
 let errorsInstrumented = false;
 
@@ -31,16 +36,45 @@ export function registerSpanErrorInstrumentation(): void {
 /**
  * If an error or unhandled promise occurs, we mark the active root span as failed
  */
-function errorCallback(): void {
+function errorCallback(error: any): void {
  const activeSpan = getActiveSpan();
  const rootSpan = activeSpan && getRootSpan(activeSpan);
  if (rootSpan) {
+ if (_isIgnoredError(error)) {
+ DEBUG_BUILD && logger.log('[Tracing] Root span: Global error occured then ignored');
+ return;
+ }
+
  const message = 'internal_error';
  DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occured`);
  rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });
  }
 }
 
+function _isIgnoredError(error: any): boolean {
+ if (!error) {
+ return false;
+ }
+
+ const errorMessage = _errorMessage(error);
+
+ const client = getClient();
+ if (!client) {
+ return false;
+ }
+
+ const options = client.getOptions();
+ if (!options) {
+ return false;
+ }
+
+ return stringMatchesSomePattern(errorMessage, options.ignoreErrors);
+}
+
+function _errorMessage(error: any): string {
+ return String((error as HandlerDataError).msg || (error as Error).message || error);
+}
+
 // The function name will be lost when bundling but we need to be able to identify this listener later to maintain the
 // node.js default exit behaviour
 errorCallback.tag = 'sentry_tracingErrorCallback';

packages/core/test/lib/tracing/errors.test.ts

@@ -29,7 +29,10 @@ describe('registerErrorHandlers()', () => {
  beforeEach(() => {
  mockAddGlobalErrorInstrumentationHandler.mockClear();
  mockAddGlobalUnhandledRejectionInstrumentationHandler.mockClear();
- const options = getDefaultTestClientOptions({ enableTracing: true });
+ const options = getDefaultTestClientOptions({
+ enableTracing: true,
+ ignoreErrors: ['entity not found', /some error that will not happen.*/],
+ });
  const client = new TestClient(options);
  setCurrentClient(client);
  client.init();
@@ -76,4 +79,22 @@ describe('registerErrorHandlers()', () => {
  expect(spanToJSON(span).status).toBe('internal_error');
  });
  });
+
+ it('does not set status for transaction on scope on an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockErrorCallback({ msg: 'Database entity not found!' });
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
+
+ it('does not set status for transaction on scope on unhandledrejection for an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockUnhandledRejectionCallback('Database entity not found!');
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
 });

packages/core/src/tracing/errors.ts

@@ -1,12 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import {
  addGlobalErrorInstrumentationHandler,
  addGlobalUnhandledRejectionInstrumentationHandler,
  logger,
+ stringMatchesSomePattern,
 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { getActiveSpan, getRootSpan } from '../utils/spanUtils';
+import { getClient } from '../currentScopes';
 import { SPAN_STATUS_ERROR } from './spanstatus';
+import { type HandlerDataError } from '@sentry/types';
 
 let errorsInstrumented = false;
 
@@ -31,16 +36,45 @@ export function registerSpanErrorInstrumentation(): void {
 /**
  * If an error or unhandled promise occurs, we mark the active root span as failed
  */
-function errorCallback(): void {
+function errorCallback(error: any): void {
  const activeSpan = getActiveSpan();
  const rootSpan = activeSpan && getRootSpan(activeSpan);
  if (rootSpan) {
+ if (_isIgnoredError(error)) {
+ DEBUG_BUILD && logger.log('[Tracing] Root span: Global error occured then ignored');
+ return;
+ }
+
  const message = 'internal_error';
  DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occured`);
  rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });
  }
 }
 
+function _isIgnoredError(error: any): boolean {
+ if (!error) {
+ return false;
+ }
+
+ const errorMessage = _errorMessage(error);
+
+ const client = getClient();
+ if (!client) {
+ return false;
+ }
+
+ const options = client.getOptions();
+ if (!options) {
+ return false;
+ }
+
+ return stringMatchesSomePattern(errorMessage, options.ignoreErrors);
+}
+
+function _errorMessage(error: any): string {
+ return String((error as HandlerDataError).msg || (error as Error).message || error);
+}
+
 // The function name will be lost when bundling but we need to be able to identify this listener later to maintain the
 // node.js default exit behaviour
 errorCallback.tag = 'sentry_tracingErrorCallback';

packages/core/test/lib/tracing/errors.test.ts

@@ -29,7 +29,10 @@ describe('registerErrorHandlers()', () => {
  beforeEach(() => {
  mockAddGlobalErrorInstrumentationHandler.mockClear();
  mockAddGlobalUnhandledRejectionInstrumentationHandler.mockClear();
- const options = getDefaultTestClientOptions({ enableTracing: true });
+ const options = getDefaultTestClientOptions({
+ enableTracing: true,
+ ignoreErrors: ['entity not found', /some error that will not happen.*/],
+ });
  const client = new TestClient(options);
  setCurrentClient(client);
  client.init();
@@ -76,4 +79,22 @@ describe('registerErrorHandlers()', () => {
  expect(spanToJSON(span).status).toBe('internal_error');
  });
  });
+
+ it('does not set status for transaction on scope on an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockErrorCallback({ msg: 'Database entity not found!' });
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
+
+ it('does not set status for transaction on scope on unhandledrejection for an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockUnhandledRejectionCallback('Database entity not found!');
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
 });

packages/core/src/tracing/errors.ts

@@ -1,12 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import {
  addGlobalErrorInstrumentationHandler,
  addGlobalUnhandledRejectionInstrumentationHandler,
  logger,
+ stringMatchesSomePattern,
 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { getActiveSpan, getRootSpan } from '../utils/spanUtils';
+import { getClient } from '../currentScopes';
 import { SPAN_STATUS_ERROR } from './spanstatus';
+import { type HandlerDataError } from '@sentry/types';
 
 let errorsInstrumented = false;
 
@@ -31,16 +36,45 @@ export function registerSpanErrorInstrumentation(): void {
 /**
  * If an error or unhandled promise occurs, we mark the active root span as failed
  */
-function errorCallback(): void {
+function errorCallback(error: any): void {
  const activeSpan = getActiveSpan();
  const rootSpan = activeSpan && getRootSpan(activeSpan);
  if (rootSpan) {
+ if (_isIgnoredError(error)) {
+ DEBUG_BUILD && logger.log('[Tracing] Root span: Global error occured then ignored');
+ return;
+ }
+
  const message = 'internal_error';
  DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occured`);
  rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });
  }
 }
 
+function _isIgnoredError(error: any): boolean {
+ if (!error) {
+ return false;
+ }
+
+ const errorMessage = _errorMessage(error);
+
+ const client = getClient();
+ if (!client) {
+ return false;
+ }
+
+ const options = client.getOptions();
+ if (!options) {
+ return false;
+ }
+
+ return stringMatchesSomePattern(errorMessage, options.ignoreErrors);
+}
+
+function _errorMessage(error: any): string {
+ return String((error as HandlerDataError).msg || (error as Error).message || error);
+}
+
 // The function name will be lost when bundling but we need to be able to identify this listener later to maintain the
 // node.js default exit behaviour
 errorCallback.tag = 'sentry_tracingErrorCallback';

packages/core/test/lib/tracing/errors.test.ts

@@ -29,7 +29,10 @@ describe('registerErrorHandlers()', () => {
  beforeEach(() => {
  mockAddGlobalErrorInstrumentationHandler.mockClear();
  mockAddGlobalUnhandledRejectionInstrumentationHandler.mockClear();
- const options = getDefaultTestClientOptions({ enableTracing: true });
+ const options = getDefaultTestClientOptions({
+ enableTracing: true,
+ ignoreErrors: ['entity not found', /some error that will not happen.*/],
+ });
  const client = new TestClient(options);
  setCurrentClient(client);
  client.init();
@@ -76,4 +79,22 @@ describe('registerErrorHandlers()', () => {
  expect(spanToJSON(span).status).toBe('internal_error');
  });
  });
+
+ it('does not set status for transaction on scope on an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockErrorCallback({ msg: 'Database entity not found!' });
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
+
+ it('does not set status for transaction on scope on unhandledrejection for an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockUnhandledRejectionCallback('Database entity not found!');
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
 });

packages/core/src/tracing/errors.ts

@@ -1,12 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import {
  addGlobalErrorInstrumentationHandler,
  addGlobalUnhandledRejectionInstrumentationHandler,
  logger,
+ stringMatchesSomePattern,
 } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { getActiveSpan, getRootSpan } from '../utils/spanUtils';
+import { getClient } from '../currentScopes';
 import { SPAN_STATUS_ERROR } from './spanstatus';
+import { type HandlerDataError } from '@sentry/types';
 
 let errorsInstrumented = false;
 
@@ -31,16 +36,45 @@ export function registerSpanErrorInstrumentation(): void {
 /**
  * If an error or unhandled promise occurs, we mark the active root span as failed
  */
-function errorCallback(): void {
+function errorCallback(error: any): void {
  const activeSpan = getActiveSpan();
  const rootSpan = activeSpan && getRootSpan(activeSpan);
  if (rootSpan) {
+ if (_isIgnoredError(error)) {
+ DEBUG_BUILD && logger.log('[Tracing] Root span: Global error occured then ignored');
+ return;
+ }
+
  const message = 'internal_error';
  DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occured`);
  rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });
  }
 }
 
+function _isIgnoredError(error: any): boolean {
+ if (!error) {
+ return false;
+ }
+
+ const errorMessage = _errorMessage(error);
+
+ const client = getClient();
+ if (!client) {
+ return false;
+ }
+
+ const options = client.getOptions();
+ if (!options) {
+ return false;
+ }
+
+ return stringMatchesSomePattern(errorMessage, options.ignoreErrors);
+}
+
+function _errorMessage(error: any): string {
+ return String((error as HandlerDataError).msg || (error as Error).message || error);
+}
+
 // The function name will be lost when bundling but we need to be able to identify this listener later to maintain the
 // node.js default exit behaviour
 errorCallback.tag = 'sentry_tracingErrorCallback';

packages/core/test/lib/tracing/errors.test.ts

@@ -29,7 +29,10 @@ describe('registerErrorHandlers()', () => {
  beforeEach(() => {
  mockAddGlobalErrorInstrumentationHandler.mockClear();
  mockAddGlobalUnhandledRejectionInstrumentationHandler.mockClear();
- const options = getDefaultTestClientOptions({ enableTracing: true });
+ const options = getDefaultTestClientOptions({
+ enableTracing: true,
+ ignoreErrors: ['entity not found', /some error that will not happen.*/],
+ });
  const client = new TestClient(options);
  setCurrentClient(client);
  client.init();
@@ -76,4 +79,22 @@ describe('registerErrorHandlers()', () => {
  expect(spanToJSON(span).status).toBe('internal_error');
  });
  });
+
+ it('does not set status for transaction on scope on an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockErrorCallback({ msg: 'Database entity not found!' });
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
+
+ it('does not set status for transaction on scope on unhandledrejection for an ignored error', () => {
+ registerSpanErrorInstrumentation();
+
+ startSpan({ name: 'test' }, span => {
+ mockUnhandledRejectionCallback('Database entity not found!');
+ expect(spanToJSON(span).status).toBe(undefined);
+ });
+ });
 });