✨ accept non-error as error cause

Author: mormubis

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

@@ -234,14 +234,19 @@ describe('flattenErrorCauses', () => {
     expect(errorCauses).toEqual(undefined)
   })
 
-  it('should return undefined if cause is not of type Error', () => {
+  it('should support non-Error causes with consistent structure', () => {
     const error = new Error('foo') as ErrorWithCause
-    const nestedError = { biz: 'buz', cause: new Error('boo') } as unknown as Error
-
+    const nestedError = { biz: 'buz', cause: new Error('boo') }
     error.cause = nestedError
 
     const errorCauses = flattenErrorCauses(error, ErrorSource.LOGGER)
-    expect(errorCauses?.length).toEqual(undefined)
+    expect(errorCauses?.length).toEqual(1)
+    expect(errorCauses?.[0]).toEqual({
+      message: '{"biz":"buz","cause":{}}',  // JSON stringified, cause is sanitized
+      source: ErrorSource.LOGGER,
+      type: 'object',
+      stack: undefined,
+    })
   })
 
   it('should use error to extract stack trace', () => {
@@ -259,6 +264,96 @@ describe('flattenErrorCauses', () => {
     const errorCauses = flattenErrorCauses(error, ErrorSource.LOGGER)
     expect(errorCauses?.length).toEqual(10)
   })
+
+  describe('with non-Error values', () => {
+    it('should handle string cause with consistent structure', () => {
+      const error = new Error('main') as ErrorWithCause
+      error.cause = 'string cause'
+
+      const causes = flattenErrorCauses(error, ErrorSource.CUSTOM)
+      expect(causes?.length).toBe(1)
+      expect(causes?.[0]).toEqual({
+        message: '"string cause"',  // JSON stringified
+        source: ErrorSource.CUSTOM,
+        type: 'string',
+        stack: undefined,
+      })
+    })
+
+    it('should handle object cause with consistent structure', () => {
+      const error = new Error('main') as ErrorWithCause
+      error.cause = { code: 'ERR_001', details: 'Invalid input' }
+
+      const causes = flattenErrorCauses(error, ErrorSource.CUSTOM)
+      expect(causes?.length).toBe(1)
+      expect(causes?.[0]).toEqual({
+        message: '{"code":"ERR_001","details":"Invalid input"}',
+        source: ErrorSource.CUSTOM,
+        type: 'object',
+        stack: undefined,
+      })
+    })
+
+    it('should handle number cause with consistent structure', () => {
+      const error = new Error('main') as ErrorWithCause
+      error.cause = 42
+
+      const causes = flattenErrorCauses(error, ErrorSource.CUSTOM)
+      expect(causes?.length).toBe(1)
+      expect(causes?.[0]).toEqual({
+        message: '42',
+        source: ErrorSource.CUSTOM,
+        type: 'number',
+        stack: undefined,
+      })
+    })
+
+    it('should handle mixed Error and non-Error chain', () => {
+      const error1 = new Error('first') as ErrorWithCause
+      const error2 = new Error('second') as ErrorWithCause
+      error1.cause = error2
+      error2.cause = { code: 'ERR_ROOT' }
+
+      const causes = flattenErrorCauses(error1, ErrorSource.CUSTOM)
+      expect(causes?.length).toBe(2)
+
+      // First cause: Error with full structure
+      expect(causes?.[0].message).toBe('second')
+      expect(causes?.[0].type).toBe('Error')
+      expect(causes?.[0].stack).toContain('Error')
+
+      // Second cause: Object with normalized structure
+      expect(causes?.[1]).toEqual({
+        message: '{"code":"ERR_ROOT"}',
+        source: ErrorSource.CUSTOM,
+        type: 'object',
+        stack: undefined,
+      })
+    })
+
+    it('should stop chain after non-Error cause', () => {
+      const error = new Error('main') as ErrorWithCause
+      error.cause = { value: 'data', cause: new Error('ignored') }
+
+      const causes = flattenErrorCauses(error, ErrorSource.CUSTOM)
+      expect(causes?.length).toBe(1)
+      // The entire object is captured, nested cause is sanitized
+      expect(causes?.[0].message).toContain('"value":"data"')
+      expect(causes?.[0].type).toBe('object')
+    })
+
+    it('should handle null cause', () => {
+      const error = new Error('main') as ErrorWithCause
+      error.cause = null
+      expect(flattenErrorCauses(error, ErrorSource.CUSTOM)).toBeUndefined()
+    })
+
+    it('should handle undefined cause', () => {
+      const error = new Error('main') as ErrorWithCause
+      error.cause = undefined
+      expect(flattenErrorCauses(error, ErrorSource.CUSTOM)).toBeUndefined()
+    })
+  })
 })
 
 describe('isError', () => {

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

@@ -87,17 +87,35 @@ export function isError(error: unknown): error is Error {
 }
 
 export function flattenErrorCauses(error: ErrorWithCause, parentSource: ErrorSource): RawErrorCause[] | undefined {
-  let currentError = error
   const causes: RawErrorCause[] = []
-  while (isError(currentError?.cause) && causes.length < 10) {
-    const stackTrace = computeStackTrace(currentError.cause)
-    causes.push({
-      message: currentError.cause.message,
-      source: parentSource,
-      type: stackTrace?.name,
-      stack: stackTrace && toStackTraceString(stackTrace),
-    })
-    currentError = currentError.cause
+  let currentCause = error.cause
+
+  while (currentCause !== undefined && currentCause !== null && causes.length < 10) {
+    if (isError(currentCause)) {
+      // Handle Error objects: extract structured data
+      const stackTrace = computeStackTrace(currentCause)
+      causes.push({
+        message: currentCause.message,
+        source: parentSource,
+        type: stackTrace?.name,
+        stack: stackTrace && toStackTraceString(stackTrace),
+      })
+
+      // Continue chain through Error's cause
+      currentCause = (currentCause as ErrorWithCause).cause
+    } else {
+      // Handle non-Error values: normalize to same structure
+      causes.push({
+        message: jsonStringify(sanitize(currentCause))!,
+        source: parentSource,
+        type: typeof currentCause,
+        stack: undefined,
+      })
+
+      // Terminate chain after non-Error cause
+      currentCause = undefined
+    }
   }
+
   return causes.length ? causes : undefined
 }

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

@@ -126,6 +126,27 @@ describe('error collection', () => {
       expect(error?.causes?.[1].source).toEqual(ErrorSource.CUSTOM)
     })
 
+    it('should extract non-Error causes with consistent structure', () => {
+      setupErrorCollection()
+      const error = new Error('RSA key generation failed') as ErrorWithCause
+      error.cause = { code: 'NonInteger', values: [3.14, 2.71] }
+
+      addError({
+        error,
+        handlingStack: 'Error: handling',
+        startClocks: { relative: 1234 as RelativeTime, timeStamp: 123456789 as TimeStamp },
+      })
+
+      const { error: rumError } = rawRumEvents[0].rawRumEvent as RawRumErrorEvent
+      expect(rumError.causes?.length).toBe(1)
+      expect(rumError.causes?.[0]).toEqual({
+        message: '{"code":"NonInteger","values":[3.14,2.71]}',
+        source: ErrorSource.CUSTOM,
+        type: 'object',
+        stack: undefined,
+      })
+    })
+
     it('should extract fingerprint from error', () => {
       setupErrorCollection()