✨ [RUMF-1353] Add Error.cause property

packages/core/src/domain/error/trackRuntimeError.ts

@@ -6,7 +6,13 @@ import { startUnhandledErrorCollection } from '../tracekit'
 
 export function trackRuntimeError(errorObservable: Observable<RawError>) {
   return startUnhandledErrorCollection((stackTrace, errorObject) => {
-    const { stack, message, type } = formatUnknownError(stackTrace, errorObject, 'Uncaught')
+    const { stack, message, type, causes } = formatUnknownError({
+      stackTrace,
+      errorObject,
+      nonErrorPrefix: 'Uncaught',
+      source: ErrorSource.SOURCE,
+    })
+
     errorObservable.notify({
       message,
       stack,
@@ -15,6 +21,7 @@ export function trackRuntimeError(errorObservable: Observable<RawError>) {
       startClocks: clocksNow(),
       originalError: errorObject,
       handling: ErrorHandling.UNHANDLED,
+      causes,
     })
   })
 }

packages/core/src/index.ts

@@ -58,8 +58,11 @@ export {
   formatUnknownError,
   createHandlingStack,
   RawError,
+  RawErrorCause,
+  ErrorWithCause,
   toStackTraceString,
   getFileFromStackTraceString,
+  flattenErrorCauses,
 } from './tools/error'
 export { Context, ContextArray, ContextValue } from './tools/context'
 export { areCookiesAuthorized, getCookie, setCookie, deleteCookie, COOKIE_ACCESS_DELAY } from './browser/cookie'

packages/core/src/tools/error.spec.ts

@@ -1,5 +1,12 @@
 import type { StackTrace } from '../domain/tracekit'
-import { createHandlingStack, formatUnknownError, getFileFromStackTraceString } from './error'
+import type { RawErrorCause, ErrorWithCause } from './error'
+import {
+  createHandlingStack,
+  formatUnknownError,
+  getFileFromStackTraceString,
+  flattenErrorCauses,
+  ErrorSource,
+} from './error'
 
 describe('formatUnknownError', () => {
   const NOT_COMPUTED_STACK_TRACE: StackTrace = { name: undefined, message: undefined, stack: [] } as any
@@ -33,7 +40,12 @@ describe('formatUnknownError', () => {
       ],
     }
 
-    const formatted = formatUnknownError(stack, undefined, 'Uncaught')
+    const formatted = formatUnknownError({
+      stackTrace: stack,
+      errorObject: undefined,
+      nonErrorPrefix: 'Uncaught',
+      source: 'custom',
+    })
 
     expect(formatted.message).toEqual('oh snap!')
     expect(formatted.type).toEqual('TypeError')
@@ -50,26 +62,64 @@ describe('formatUnknownError', () => {
       stack: [],
     }
 
-    const formatted = formatUnknownError(stack, undefined, 'Uncaught')
+    const formatted = formatUnknownError({
+      stackTrace: stack,
+      errorObject: undefined,
+      nonErrorPrefix: 'Uncaught',
+      source: 'custom',
+    })
 
     expect(formatted.message).toEqual('Empty message')
   })
 
   it('should format a string error', () => {
     const errorObject = 'oh snap!'
 
-    const formatted = formatUnknownError(NOT_COMPUTED_STACK_TRACE, errorObject, 'Uncaught')
+    const formatted = formatUnknownError({
+      stackTrace: NOT_COMPUTED_STACK_TRACE,
+      errorObject,
+      nonErrorPrefix: 'Uncaught',
+      source: 'custom',
+    })
 
     expect(formatted.message).toEqual('Uncaught "oh snap!"')
   })
 
   it('should format an object error', () => {
     const errorObject = { foo: 'bar' }
 
-    const formatted = formatUnknownError(NOT_COMPUTED_STACK_TRACE, errorObject, 'Uncaught')
+    const formatted = formatUnknownError({
+      stackTrace: NOT_COMPUTED_STACK_TRACE,
+      errorObject,
+      nonErrorPrefix: 'Uncaught',
+      source: 'custom',
+    })
 
     expect(formatted.message).toEqual('Uncaught {"foo":"bar"}')
   })
+
+  it('should format an object error with cause', () => {
+    const errorObject = new Error('foo: bar') as ErrorWithCause
+    const nestedErrorObject = new Error('biz: buz') as ErrorWithCause
+    const deepNestedErrorObject = new Error('fiz: buz') as ErrorWithCause
+
+    errorObject.cause = nestedErrorObject
+    nestedErrorObject.cause = deepNestedErrorObject
+
+    const formatted = formatUnknownError({
+      stackTrace: NOT_COMPUTED_STACK_TRACE,
+      errorObject,
+      nonErrorPrefix: 'Uncaught',
+      source: ErrorSource.SOURCE,
+    })
+
+    expect(formatted.causes?.length).toBe(2)
+    const causes = formatted.causes as RawErrorCause[]
+    expect(causes[0].message).toContain(nestedErrorObject.message)
+    expect(causes[0].source).toContain(ErrorSource.SOURCE)
+    expect(causes[1].message).toContain(deepNestedErrorObject.message)
+    expect(causes[1].source).toContain(ErrorSource.SOURCE)
+  })
 })
 
 describe('getFileFromStackTraceString', () => {
@@ -107,3 +157,18 @@ describe('createHandlingStack', () => {
   at userCallOne @ (.*)`)
   })
 })
+
+describe('flattenErrorCauses', () => {
+  it('should return empty array if  no cause found', () => {
+    const error = new Error('foo') as ErrorWithCause
+    const errorCauses = flattenErrorCauses({ errorObject: error, parentSource: ErrorSource.LOGGER })
+    expect(errorCauses.length).toEqual(0)
+  })
+
+  it('should only return the first 10 errors if nested chain is longer', () => {
+    const error = new Error('foo') as ErrorWithCause
+    error.cause = error
+    const errorCauses = flattenErrorCauses({ errorObject: error, parentSource: ErrorSource.LOGGER })
+    expect(errorCauses.length).toEqual(10)
+  })
+})

packages/core/src/tools/error.ts

@@ -4,6 +4,17 @@ import { callMonitored } from './monitor'
 import type { ClocksState } from './timeUtils'
 import { jsonStringify, noop } from './utils'
 
+export interface ErrorWithCause extends Error {
+  cause?: Error
+}
+
+export type RawErrorCause = {
+  message: string
+  source: string
+  type?: string
+  stack?: StackTrace
+}
+
 export interface RawError {
   startClocks: ClocksState
   message: string
@@ -13,6 +24,15 @@ export interface RawError {
   originalError?: unknown
   handling?: ErrorHandling
   handlingStack?: string
+  causes?: RawErrorCause[]
+}
+
+export interface UnknownError {
+  message: string
+  stack?: string
+  handlingStack?: string
+  type?: string
+  causes?: RawErrorCause[]
 }
 
 export const ErrorSource = {
@@ -32,12 +52,21 @@ export const enum ErrorHandling {
 
 export type ErrorSource = typeof ErrorSource[keyof typeof ErrorSource]
 
-export function formatUnknownError(
-  stackTrace: StackTrace | undefined,
-  errorObject: any,
-  nonErrorPrefix: string,
+type UnknownErrorParams = {
+  stackTrace?: StackTrace
+  errorObject: any
+  nonErrorPrefix: string
   handlingStack?: string
-) {
+  source: ErrorSource
+}
+
+export function formatUnknownError({
+  stackTrace,
+  errorObject,
+  nonErrorPrefix,
+  handlingStack,
+  source,
+}: UnknownErrorParams): UnknownError {
   if (!stackTrace || (stackTrace.message === undefined && !(errorObject instanceof Error))) {
     return {
       message: `${nonErrorPrefix} ${jsonStringify(errorObject)!}`,
@@ -47,11 +76,13 @@ export function formatUnknownError(
     }
   }
 
+  const causes = flattenErrorCauses({ errorObject, parentSource: source })
   return {
     message: stackTrace.message || 'Empty message',
     stack: toStackTraceString(stackTrace),
     handlingStack,
     type: stackTrace.name,
+    causes,
   }
 }
 
@@ -110,3 +141,21 @@ export function createHandlingStack(): string {
 
   return formattedStack!
 }
+
+type FormatErrorCausesParams = { errorObject: ErrorWithCause; parentSource: ErrorSource }
+
+export function flattenErrorCauses({ errorObject, parentSource }: FormatErrorCausesParams): RawErrorCause[] {
+  let currentError = errorObject
+  const causes: RawErrorCause[] = []
+  while (currentError?.cause && currentError.cause && causes.length < 10) {
+    const stackTrace = currentError.cause instanceof Error ? computeStackTrace(currentError.cause) : undefined
+    causes.push({
+      message: currentError.cause.message,
+      source: parentSource,
+      type: stackTrace?.name,
+      stack: stackTrace,
+    })
+    currentError = currentError.cause
+  }
+  return causes
+}

packages/rum-core/src/domain/rumEventsCollection/error/errorCollection.spec.ts

@@ -1,7 +1,8 @@
-import type { RelativeTime, TimeStamp } from '@datadog/browser-core'
+import type { RelativeTime, TimeStamp, ErrorWithCause } from '@datadog/browser-core'
 import { ErrorHandling, ErrorSource } from '@datadog/browser-core'
 import type { TestSetupBuilder } from '../../../../test/specHelper'
 import { setup } from '../../../../test/specHelper'
+import type { RawRumErrorEvent } from '../../../rawRumEvent.types'
 import { RumEventType } from '../../../rawRumEvent.types'
 import { LifeCycleEventType } from '../../lifeCycle'
 import { doStartErrorCollection } from './errorCollection'
@@ -49,6 +50,7 @@ describe('error collection', () => {
             type: 'Error',
             handling: ErrorHandling.HANDLED,
             source_type: 'browser',
+            causes: [],
           },
           type: RumEventType.ERROR,
           view: {
@@ -61,6 +63,31 @@ describe('error collection', () => {
       })
     })
 
+    it('should extract causes from error', () => {
+      const { rawRumEvents } = setupBuilder.build()
+      const error1 = new Error('foo') as ErrorWithCause
+      const error2 = new Error('bar') as ErrorWithCause
+      const error3 = new Error('biz') as ErrorWithCause
+
+      error1.cause = error2
+      error2.cause = error3
+
+      addError({
+        error: error1,
+        handlingStack: 'Error: handling foo',
+        startClocks: { relative: 1234 as RelativeTime, timeStamp: 123456789 as TimeStamp },
+      })
+      const { error } = rawRumEvents[0].rawRumEvent as RawRumErrorEvent
+      expect(error.message).toEqual('foo')
+      expect(error.source).toEqual('custom')
+
+      expect(error.causes.length).toEqual(2)
+      expect(error.causes[0].message).toEqual('bar')
+      expect(error.causes[0].source).toEqual(ErrorSource.LOGGER)
+      expect(error.causes[1].message).toEqual('biz')
+      expect(error.causes[1].source).toEqual(ErrorSource.LOGGER)
+    })
+
     it('should save the specified customer context', () => {
       const { rawRumEvents } = setupBuilder.build()
       addError({
@@ -144,6 +171,7 @@ describe('error collection', () => {
           type: 'foo',
           handling: undefined,
           source_type: 'browser',
+          causes: [],
         },
         view: {
           in_foreground: true,

packages/rum-core/src/domain/rumEventsCollection/error/errorCollection.ts

@@ -74,7 +74,13 @@ function computeRawError(error: unknown, handlingStack: string, startClocks: Clo
       originalError: error,
       handling: ErrorHandling.HANDLED,
     },
-    formatUnknownError(stackTrace, error, 'Provided', handlingStack)
+    formatUnknownError({
+      stackTrace,
+      errorObject: error,
+      nonErrorPrefix: 'Provided',
+      handlingStack,
+      source: ErrorSource.CUSTOM,
+    })
   )
 }
 
@@ -92,6 +98,7 @@ function processError(
       handling_stack: error.handlingStack,
       type: error.type,
       handling: error.handling,
+      causes: error.causes ?? [],
       source_type: 'browser',
     },
     type: RumEventType.ERROR as const,

packages/rum-core/src/rawRumEvent.types.ts

@@ -6,6 +6,7 @@ import type {
   ResourceType,
   ServerDuration,
   TimeStamp,
+  RawErrorCause,
 } from '@datadog/browser-core'
 import type { RumSessionPlan } from './domain/rumSessionManager'
 
@@ -47,7 +48,7 @@ export interface PerformanceResourceDetailsElement {
   start: ServerDuration
 }
 
-export interface RawRumErrorEvent {
+export type RawRumErrorEvent = {
   date: TimeStamp
   type: RumEventType.ERROR
   error: {
@@ -58,6 +59,7 @@ export interface RawRumErrorEvent {
     source: ErrorSource
     message: string
     handling?: ErrorHandling
+    causes: RawErrorCause[]
     source_type: 'browser'
   }
   view?: {

packages/rum-core/test/fixtures.ts

@@ -44,6 +44,7 @@ export function createRawRumEvent(type: RumEventType, overrides?: Context): RawR
             source: ErrorSource.SOURCE,
             handling: ErrorHandling.HANDLED,
             source_type: 'browser',
+            causes: [],
           },
         },
         overrides