feat: Don't truncate error messages (#15818)

Ref https://github.com/getsentry/projects/issues/837 for for not
truncating error messages and letting relay do that.

Kinda undoes #8593

Should be merged after
#15819 because
otherwise, we keep humongous strings in memory.

Author: lforst

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);

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,

dev-packages/browser-integration-tests/suites/public-api/instrumentation/onUnhandledRejection/thrown-string-large/subject.js

@@ -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,

dev-packages/browser-integration-tests/suites/public-api/instrumentation/onUnhandledRejection/thrown-string-large/test.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;

packages/browser/src/integrations/linkederrors.ts

@@ -1,15 +1,13 @@
 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.
  */
 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;
-  });
-}

packages/core/src/integrations/linkederrors.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);

packages/core/src/utils-hoist/aggregate-errors.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,15 +30,15 @@ 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 } });
   });
 
   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',
-            },
-          },
-        ],
-      },
-    });
-  });
 });