diff --git a/dev-packages/browser-integration-tests/suites/public-api/captureException/linkedErrors/subject.js b/dev-packages/browser-integration-tests/suites/public-api/captureException/linkedErrors/subject.js index f7eb81412b13..1fd43c508071 100644 --- a/dev-packages/browser-integration-tests/suites/public-api/captureException/linkedErrors/subject.js +++ b/dev-packages/browser-integration-tests/suites/public-api/captureException/linkedErrors/subject.js @@ -1,13 +1,13 @@ -const wat = new Error(`This is a very long message that should be truncated and will be, -this is a very long message that should be truncated and will be, -this is a very long message that should be truncated and will be, -this is a very long message that should be truncated and will be, -this is a very long message that should be truncated and will be`); +const wat = new Error(`This is a very long message that should not be truncated and won't be, +this is a very long message that should not be truncated and won't be, +this is a very long message that should not be truncated and won't be, +this is a very long message that should not be truncated and won't be, +this is a very long message that should not be truncated and won't be`); -wat.cause = new Error(`This is a very long message that should be truncated and hopefully will be, -this is a very long message that should be truncated and hopefully will be, -this is a very long message that should be truncated and hopefully will be, -this is a very long message that should be truncated and hopefully will be, -this is a very long message that should be truncated and hopefully will be,`); +wat.cause = new Error(`This is a very long message that should not be truncated and hopefully won't be, +this is a very long message that should not be truncated and hopefully won't be, +this is a very long message that should not be truncated and hopefully won't be, +this is a very long message that should not be truncated and hopefully won't be, +this is a very long message that should not be truncated and hopefully won't be`); Sentry.captureException(wat); diff --git a/dev-packages/browser-integration-tests/suites/public-api/captureException/linkedErrors/test.ts b/dev-packages/browser-integration-tests/suites/public-api/captureException/linkedErrors/test.ts index 61dc0e3418f6..2b9910e38b1d 100644 --- a/dev-packages/browser-integration-tests/suites/public-api/captureException/linkedErrors/test.ts +++ b/dev-packages/browser-integration-tests/suites/public-api/captureException/linkedErrors/test.ts @@ -12,10 +12,11 @@ sentryTest('should capture a linked error with messages', async ({ getLocalTestU expect(eventData.exception?.values).toHaveLength(2); expect(eventData.exception?.values?.[0]).toMatchObject({ type: 'Error', - value: `This is a very long message that should be truncated and hopefully will be, -this is a very long message that should be truncated and hopefully will be, -this is a very long message that should be truncated and hopefully will be, -this is a very long me...`, + value: `This is a very long message that should not be truncated and hopefully won't be, +this is a very long message that should not be truncated and hopefully won't be, +this is a very long message that should not be truncated and hopefully won't be, +this is a very long message that should not be truncated and hopefully won't be, +this is a very long message that should not be truncated and hopefully won't be`, mechanism: { type: 'chained', handled: true, @@ -26,10 +27,11 @@ this is a very long me...`, }); expect(eventData.exception?.values?.[1]).toMatchObject({ type: 'Error', - value: `This is a very long message that should be truncated and will be, -this is a very long message that should be truncated and will be, -this is a very long message that should be truncated and will be, -this is a very long message that should be truncated...`, + value: `This is a very long message that should not be truncated and won't be, +this is a very long message that should not be truncated and won't be, +this is a very long message that should not be truncated and won't be, +this is a very long message that should not be truncated and won't be, +this is a very long message that should not be truncated and won't be`, mechanism: { type: 'generic', handled: true, diff --git a/dev-packages/browser-integration-tests/suites/public-api/instrumentation/onUnhandledRejection/thrown-string-large/subject.js b/dev-packages/browser-integration-tests/suites/public-api/instrumentation/onUnhandledRejection/thrown-string-large/subject.js deleted file mode 100644 index aae0c81d4df9..000000000000 --- a/dev-packages/browser-integration-tests/suites/public-api/instrumentation/onUnhandledRejection/thrown-string-large/subject.js +++ /dev/null @@ -1,9 +0,0 @@ -function run() { - const reason = 'stringError'.repeat(100); - const promise = Promise.reject(reason); - const event = new PromiseRejectionEvent('unhandledrejection', { promise, reason }); - // simulate window.onunhandledrejection without generating a Script error - window.onunhandledrejection(event); -} - -run(); diff --git a/dev-packages/browser-integration-tests/suites/public-api/instrumentation/onUnhandledRejection/thrown-string-large/test.ts b/dev-packages/browser-integration-tests/suites/public-api/instrumentation/onUnhandledRejection/thrown-string-large/test.ts deleted file mode 100644 index e198d6f944f0..000000000000 --- a/dev-packages/browser-integration-tests/suites/public-api/instrumentation/onUnhandledRejection/thrown-string-large/test.ts +++ /dev/null @@ -1,22 +0,0 @@ -import { expect } from '@playwright/test'; -import type { Event } from '@sentry/core'; - -import { sentryTest } from '../../../../../utils/fixtures'; -import { getFirstSentryEnvelopeRequest } from '../../../../../utils/helpers'; - -sentryTest('should capture unhandledrejection with a large string', async ({ getLocalTestUrl, page }) => { - const url = await getLocalTestUrl({ testDir: __dirname }); - - const eventData = await getFirstSentryEnvelopeRequest(page, url); - - expect(eventData.exception?.values).toHaveLength(1); - expect(eventData.exception?.values?.[0]).toMatchObject({ - type: 'UnhandledRejection', - value: - 'Non-Error promise rejection captured with value: stringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstringErrorstr...', - mechanism: { - type: 'onunhandledrejection', - handled: false, - }, - }); -}); diff --git a/packages/browser/src/integrations/linkederrors.ts b/packages/browser/src/integrations/linkederrors.ts index 4b99ac876386..d0eace11aadb 100644 --- a/packages/browser/src/integrations/linkederrors.ts +++ b/packages/browser/src/integrations/linkederrors.ts @@ -25,7 +25,6 @@ const _linkedErrorsIntegration = ((options: LinkedErrorsOptions = {}) => { // This differs from the LinkedErrors integration in core by using a different exceptionFromError function exceptionFromError, options.stackParser, - options.maxValueLength, key, limit, event, diff --git a/packages/core/src/integrations/linkederrors.ts b/packages/core/src/integrations/linkederrors.ts index caaefae1a6d5..e5a6b84918c2 100644 --- a/packages/core/src/integrations/linkederrors.ts +++ b/packages/core/src/integrations/linkederrors.ts @@ -22,15 +22,7 @@ const _linkedErrorsIntegration = ((options: LinkedErrorsOptions = {}) => { preprocessEvent(event, hint, client) { const options = client.getOptions(); - applyAggregateErrorsToEvent( - exceptionFromError, - options.stackParser, - options.maxValueLength, - key, - limit, - event, - hint, - ); + applyAggregateErrorsToEvent(exceptionFromError, options.stackParser, key, limit, event, hint); }, }; }) satisfies IntegrationFn; diff --git a/packages/core/src/utils-hoist/aggregate-errors.ts b/packages/core/src/utils-hoist/aggregate-errors.ts index 606b2d12161e..33728c03edba 100644 --- a/packages/core/src/utils-hoist/aggregate-errors.ts +++ b/packages/core/src/utils-hoist/aggregate-errors.ts @@ -1,7 +1,6 @@ import type { Event, EventHint, Exception, ExtendedError, StackParser } from '../types-hoist'; import { isInstanceOf } from './is'; -import { truncate } from './string'; /** * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter. @@ -9,7 +8,6 @@ import { truncate } from './string'; export function applyAggregateErrorsToEvent( exceptionFromErrorImplementation: (stackParser: StackParser, ex: Error) => Exception, parser: StackParser, - maxValueLimit: number = 250, key: string, limit: number, event: Event, @@ -25,18 +23,15 @@ export function applyAggregateErrorsToEvent( // We only create exception grouping if there is an exception in the event. if (originalException) { - event.exception.values = truncateAggregateExceptions( - aggregateExceptionsFromError( - exceptionFromErrorImplementation, - parser, - limit, - hint.originalException as ExtendedError, - key, - event.exception.values, - originalException, - 0, - ), - maxValueLimit, + event.exception.values = aggregateExceptionsFromError( + exceptionFromErrorImplementation, + parser, + limit, + hint.originalException as ExtendedError, + key, + event.exception.values, + originalException, + 0, ); } } @@ -129,17 +124,3 @@ function applyExceptionGroupFieldsForChildException( parent_id: parentId, }; } - -/** - * Truncate the message (exception.value) of all exceptions in the event. - * Because this event processor is ran after `applyClientOptions`, - * we need to truncate the message of the added exceptions here. - */ -function truncateAggregateExceptions(exceptions: Exception[], maxValueLength: number): Exception[] { - return exceptions.map(exception => { - if (exception.value) { - exception.value = truncate(exception.value, maxValueLength); - } - return exception; - }); -} diff --git a/packages/core/src/utils/prepareEvent.ts b/packages/core/src/utils/prepareEvent.ts index e417640a387a..edb4e8d2eac4 100644 --- a/packages/core/src/utils/prepareEvent.ts +++ b/packages/core/src/utils/prepareEvent.ts @@ -144,15 +144,6 @@ export function applyClientOptions(event: Event, options: ClientOptions): void { event.dist = dist; } - if (event.message) { - event.message = truncate(event.message, maxValueLength); - } - - const exception = event.exception?.values?.[0]; - if (exception?.value) { - exception.value = truncate(exception.value, maxValueLength); - } - const request = event.request; if (request?.url) { request.url = truncate(request.url, maxValueLength); diff --git a/packages/core/test/utils-hoist/aggregate-errors.test.ts b/packages/core/test/utils-hoist/aggregate-errors.test.ts index bc6aa2a99d19..2ec932cbd3a9 100644 --- a/packages/core/test/utils-hoist/aggregate-errors.test.ts +++ b/packages/core/test/utils-hoist/aggregate-errors.test.ts @@ -21,7 +21,7 @@ describe('applyAggregateErrorsToEvent()', () => { test('should not do anything if event does not contain an exception', () => { const event: Event = { exception: undefined }; const eventHint: EventHint = { originalException: new Error() }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, 'cause', 100, event, eventHint); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, eventHint); // no changes expect(event).toStrictEqual({ exception: undefined }); @@ -30,7 +30,7 @@ describe('applyAggregateErrorsToEvent()', () => { test('should not do anything if event does not contain exception values', () => { const event: Event = { exception: { values: undefined } }; const eventHint: EventHint = { originalException: new Error() }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, 'cause', 100, event, eventHint); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, eventHint); // no changes expect(event).toStrictEqual({ exception: { values: undefined } }); @@ -38,7 +38,7 @@ describe('applyAggregateErrorsToEvent()', () => { test('should not do anything if event does not contain an event hint', () => { const event: Event = { exception: { values: [] } }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, 'cause', 100, event, undefined); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, undefined); // no changes expect(event).toStrictEqual({ exception: { values: [] } }); @@ -47,7 +47,7 @@ describe('applyAggregateErrorsToEvent()', () => { test('should not do anything if the event hint does not contain an original exception', () => { const event: Event = { exception: { values: [] } }; const eventHint: EventHint = { originalException: undefined }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, 'cause', 100, event, eventHint); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, eventHint); // no changes expect(event).toStrictEqual({ exception: { values: [] } }); @@ -62,7 +62,7 @@ describe('applyAggregateErrorsToEvent()', () => { const event: Event = { exception: { values: [exceptionFromError(stackParser, originalException)] } }; const eventHint: EventHint = { originalException }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, key, 100, event, eventHint); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, key, 100, event, eventHint); expect(event).toStrictEqual({ exception: { values: [ @@ -108,7 +108,7 @@ describe('applyAggregateErrorsToEvent()', () => { const event: Event = { exception: { values: [exceptionFromError(stackParser, originalException)] } }; const eventHint: EventHint = { originalException }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, 'cause', 100, event, eventHint); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, eventHint); // no changes expect(event).toStrictEqual({ exception: { values: [exceptionFromError(stackParser, originalException)] } }); @@ -127,7 +127,7 @@ describe('applyAggregateErrorsToEvent()', () => { } const eventHint: EventHint = { originalException }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, key, 5, event, eventHint); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, key, 5, event, eventHint); // 6 -> one for original exception + 5 linked expect(event.exception?.values).toHaveLength(5 + 1); @@ -153,7 +153,7 @@ describe('applyAggregateErrorsToEvent()', () => { const event: Event = { exception: { values: [exceptionFromError(stackParser, fakeAggregateError)] } }; const eventHint: EventHint = { originalException: fakeAggregateError }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, 'cause', 100, event, eventHint); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, eventHint); expect(event.exception?.values?.[event.exception.values.length - 1]?.mechanism?.type).toBe('instrument'); }); @@ -170,7 +170,7 @@ describe('applyAggregateErrorsToEvent()', () => { const event: Event = { exception: { values: [exceptionFromError(stackParser, fakeAggregateError1)] } }; const eventHint: EventHint = { originalException: fakeAggregateError1 }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, 'cause', 100, event, eventHint); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, eventHint); expect(event).toStrictEqual({ exception: { values: [ @@ -254,7 +254,7 @@ describe('applyAggregateErrorsToEvent()', () => { const event: Event = { exception: { values: [exceptionFromError(stackParser, originalException)] } }; const eventHint: EventHint = { originalException }; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, undefined, key, 100, event, eventHint); + applyAggregateErrorsToEvent(exceptionFromError, stackParser, key, 100, event, eventHint); expect(event).toStrictEqual({ exception: { values: [ @@ -293,53 +293,4 @@ describe('applyAggregateErrorsToEvent()', () => { }, }); }); - - test('should truncate the exception values if they exceed the `maxValueLength` option', () => { - const originalException: ExtendedError = new Error('Root Error with long message'); - originalException.cause = new Error('Nested Error 1 with longer message'); - originalException.cause.cause = new Error('Nested Error 2 with longer message with longer message'); - - const event: Event = { exception: { values: [exceptionFromError(stackParser, originalException)] } }; - const eventHint: EventHint = { originalException }; - - const maxValueLength = 15; - applyAggregateErrorsToEvent(exceptionFromError, stackParser, maxValueLength, 'cause', 10, event, eventHint); - expect(event).toStrictEqual({ - exception: { - values: [ - { - type: 'Error', - value: 'Nested Error 2 ...', - mechanism: { - exception_id: 2, - handled: true, - parent_id: 1, - source: 'cause', - type: 'chained', - }, - }, - { - type: 'Error', - value: 'Nested Error 1 ...', - mechanism: { - exception_id: 1, - handled: true, - parent_id: 0, - source: 'cause', - type: 'chained', - }, - }, - { - type: 'Error', - value: 'Root Error with...', - mechanism: { - exception_id: 0, - handled: true, - type: 'instrument', - }, - }, - ], - }, - }); - }); });