@posthog/core 1.1.0 → 1.2.0

package/src/error-tracking/coercers/object-coercer.ts

@@ -0,0 +1,76 @@
+import { isEmptyString, isError, isEvent, isString } from '@/utils'
+import { CoercingContext, ErrorTrackingCoercer, ExceptionLike, SeverityLevel, severityLevels } from '../types'
+import { extractExceptionKeysForMessage } from './utils'
+
+type ObjectLike = Record<string, unknown>
+
+export class ObjectCoercer implements ErrorTrackingCoercer<ObjectLike> {
+  match(candidate: unknown): candidate is ObjectLike {
+    return typeof candidate === 'object' && candidate !== null
+  }
+
+  coerce(candidate: ObjectLike, ctx: CoercingContext): ExceptionLike | undefined {
+    const errorProperty = this.getErrorPropertyFromObject(candidate)
+    if (errorProperty) {
+      return ctx.apply(errorProperty)
+    } else {
+      return {
+        type: this.getType(candidate),
+        value: this.getValue(candidate),
+        stack: ctx.syntheticException?.stack,
+        level: this.isSeverityLevel(candidate.level) ? candidate.level : 'error',
+        synthetic: true,
+      }
+    }
+  }
+
+  getType(err: Record<string, unknown>): string {
+    return isEvent(err) ? err.constructor.name : 'Error'
+  }
+
+  getValue(err: object) {
+    if ('name' in err && typeof err.name === 'string') {
+      let message = `'${err.name}' captured as exception`
+
+      if ('message' in err && typeof err.message === 'string') {
+        message += ` with message: '${err.message}'`
+      }
+
+      return message
+    } else if ('message' in err && typeof err.message === 'string') {
+      return err.message
+    }
+
+    const className = this.getObjectClassName(err)
+    const keys = extractExceptionKeysForMessage(err)
+
+    return `${className && className !== 'Object' ? `'${className}'` : 'Object'} captured as exception with keys: ${keys}`
+  }
+
+  private isSeverityLevel(x: unknown): x is SeverityLevel {
+    return isString(x) && !isEmptyString(x) && severityLevels.indexOf(x as SeverityLevel) >= 0
+  }
+
+  /** If a plain object has a property that is an `Error`, return this error. */
+  private getErrorPropertyFromObject(obj: Record<string, unknown>): Error | undefined {
+    for (const prop in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+        const value = obj[prop]
+        if (isError(value)) {
+          return value
+        }
+      }
+    }
+
+    return undefined
+  }
+
+  private getObjectClassName(obj: unknown): string | undefined {
+    try {
+      const prototype: unknown | null = Object.getPrototypeOf(obj)
+      return prototype ? prototype.constructor.name : undefined
+    } catch (e) {
+      return undefined
+    }
+  }
+}

package/src/error-tracking/coercers/primitive-coercer.ts

@@ -0,0 +1,19 @@
+import { isPrimitive } from '@/utils'
+import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '../types'
+
+export type PrimitiveType = null | undefined | boolean | number | string | symbol | bigint
+
+export class PrimitiveCoercer implements ErrorTrackingCoercer<PrimitiveType> {
+  match(candidate: unknown): candidate is PrimitiveType {
+    return isPrimitive(candidate)
+  }
+
+  coerce(value: PrimitiveType, ctx: CoercingContext): ExceptionLike | undefined {
+    return {
+      type: 'Error',
+      value: `Primitive value captured as exception: ${String(value)}`,
+      stack: ctx.syntheticException?.stack,
+      synthetic: true,
+    }
+  }
+}

package/src/error-tracking/coercers/promise-rejection-event.spec.ts

@@ -0,0 +1,77 @@
+import { CoercingContext } from '../types'
+import { PromiseRejectionEventCoercer } from './promise-rejection-event'
+
+type PromiseRejectionEventTypes = 'rejectionhandled' | 'unhandledrejection'
+
+type PromiseRejectionEventInit = {
+  promise: Promise<any>
+  reason: any
+}
+
+class PromiseRejectionEvent extends Event {
+  public readonly promise: Promise<any>
+  public readonly reason: any
+
+  public constructor(type: PromiseRejectionEventTypes, options: PromiseRejectionEventInit) {
+    super(type)
+
+    this.promise = options.promise
+    this.reason = options.reason
+  }
+}
+
+describe('PromiseRejectionEventCoercer', () => {
+  const coercer = new PromiseRejectionEventCoercer()
+
+  it('should coerce event with reason is a primitive', () => {
+    const pre = new PromiseRejectionEvent('unhandledrejection', {
+      promise: Promise.resolve('wat'),
+      reason: 'My house is on fire',
+    })
+
+    const ctx = {
+      apply: jest.fn(() => ({
+        type: 'MockType',
+        value: 'MockValue',
+        synthetic: true,
+      })),
+      next: jest.fn(),
+    } as CoercingContext
+
+    expect(coercer.coerce(pre, ctx)).toMatchObject({
+      type: 'UnhandledRejection',
+      value: 'Non-Error promise rejection captured with value: My house is on fire',
+      synthetic: true,
+    })
+  })
+
+  it('should coerce event with reason is an error', () => {
+    class CustomTestError extends Error {
+      constructor(message: string) {
+        super(message)
+        this.name = 'CustomTestError'
+      }
+    }
+
+    const pre = new PromiseRejectionEvent('unhandledrejection', {
+      promise: Promise.resolve('wat'),
+      reason: new CustomTestError('My house is on fire'),
+    })
+
+    const ctx = {
+      apply: jest.fn((err: Error) => ({
+        type: err.name,
+        value: err.message,
+        stack: err.stack,
+        synthetic: false,
+      })),
+      next: jest.fn(),
+    } as CoercingContext
+
+    expect(coercer.coerce(pre, ctx)).toMatchObject({
+      type: 'CustomTestError',
+      value: 'My house is on fire',
+      synthetic: false,
+    })
+  })
+})

package/src/error-tracking/coercers/promise-rejection-event.ts

@@ -0,0 +1,53 @@
+import { isBuiltin, isPrimitive } from '@/utils'
+import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '../types'
+
+// Web only
+export class PromiseRejectionEventCoercer implements ErrorTrackingCoercer<PromiseRejectionEvent> {
+  match(err: unknown): err is PromiseRejectionEvent {
+    return isBuiltin(err, 'PromiseRejectionEvent')
+  }
+
+  coerce(err: PromiseRejectionEvent, ctx: CoercingContext): ExceptionLike | undefined {
+    const reason = this.getUnhandledRejectionReason(err)
+    if (isPrimitive(reason)) {
+      return {
+        type: 'UnhandledRejection',
+        value: `Non-Error promise rejection captured with value: ${String(reason)}`,
+        stack: ctx.syntheticException?.stack,
+        synthetic: true,
+      }
+    } else {
+      return ctx.apply(reason)
+    }
+  }
+
+  private getUnhandledRejectionReason(error: unknown): unknown {
+    if (isPrimitive(error)) {
+      return error
+    }
+
+    // dig the object of the rejection out of known event types
+    try {
+      type ErrorWithReason = { reason: unknown }
+      // PromiseRejectionEvents store the object of the rejection under 'reason'
+      // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
+      if ('reason' in (error as ErrorWithReason)) {
+        return (error as ErrorWithReason).reason
+      }
+
+      type CustomEventWithDetail = { detail: { reason: unknown } }
+      // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents
+      // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into
+      // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec
+      // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and
+      // https://github.com/getsentry/sentry-javascript/issues/2380
+      if ('detail' in (error as CustomEventWithDetail) && 'reason' in (error as CustomEventWithDetail).detail) {
+        return (error as CustomEventWithDetail).detail.reason
+      }
+    } catch {
+      // no-empty
+    }
+
+    return error
+  }
+}

package/src/error-tracking/coercers/string-coercer.spec.ts

@@ -0,0 +1,26 @@
+import { CoercingContext } from '../types'
+import { StringCoercer } from './string-coercer'
+
+describe('PromiseRejectionEventCoercer', () => {
+  const coercer = new StringCoercer()
+
+  it('should parse string', () => {
+    const infos = coercer.getInfos('My house is on fire')
+    expect(infos).toMatchObject([undefined, 'My house is on fire'])
+  })
+
+  it('should parse errors', () => {
+    const infos = coercer.getInfos('ReferenceError: My house is on fire')
+    expect(infos).toMatchObject(['ReferenceError', 'My house is on fire'])
+  })
+
+  it('should discard prefix', () => {
+    const infos = coercer.getInfos('Uncaught exception: ReferenceError: My house is on fire')
+    expect(infos).toMatchObject(['ReferenceError', 'My house is on fire'])
+  })
+
+  it('should not match other patterns', () => {
+    const infos = coercer.getInfos('ValueError: ReferenceError: My house is on fire')
+    expect(infos).toMatchObject([undefined, 'ValueError: ReferenceError: My house is on fire'])
+  })
+})

package/src/error-tracking/coercers/string-coercer.ts

@@ -0,0 +1,31 @@
+import { ExceptionLike, ErrorTrackingCoercer, CoercingContext } from '../types'
+
+const ERROR_TYPES_PATTERN =
+  /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i
+
+export class StringCoercer implements ErrorTrackingCoercer<string> {
+  match(input: unknown): input is string {
+    return typeof input === 'string'
+  }
+
+  coerce(input: string, ctx: CoercingContext): ExceptionLike {
+    const [type, value] = this.getInfos(input)
+    return {
+      type: type ?? 'Error',
+      value: value ?? input,
+      stack: ctx.syntheticException?.stack,
+      synthetic: true,
+    }
+  }
+
+  getInfos(candidate: string): [string, string] {
+    let type = 'Error'
+    let value = candidate
+    const groups = candidate.match(ERROR_TYPES_PATTERN)
+    if (groups) {
+      type = groups[1]
+      value = groups[2]
+    }
+    return [type, value]
+  }
+}

package/src/error-tracking/coercers/utils.ts

@@ -0,0 +1,33 @@
+export function truncate(str: string, max: number = 0): string {
+  if (typeof str !== 'string' || max === 0) {
+    return str
+  }
+  return str.length <= max ? str : `${str.slice(0, max)}...`
+}
+
+/**
+ * Given any captured exception, extract its keys and create a sorted
+ * and truncated list that will be used inside the event message.
+ * eg. `Non-error exception captured with keys: foo, bar, baz`
+ */
+export function extractExceptionKeysForMessage(err: object, maxLength = 40): string {
+  const keys = Object.keys(err)
+  keys.sort()
+
+  if (!keys.length) {
+    return '[object has no keys]'
+  }
+
+  for (let i = keys.length; i > 0; i--) {
+    const serialized = keys.slice(0, i).join(', ')
+    if (serialized.length > maxLength) {
+      continue
+    }
+    if (i === keys.length) {
+      return serialized
+    }
+    return serialized.length <= maxLength ? serialized : `${serialized.slice(0, maxLength)}...`
+  }
+
+  return ''
+}

package/src/error-tracking/error-properties-builder.coerce.spec.ts

@@ -0,0 +1,202 @@
+import { DOMExceptionCoercer, ErrorEventCoercer, ErrorCoercer, ObjectCoercer, StringCoercer } from './coercers'
+import { PrimitiveCoercer } from './coercers/primitive-coercer'
+import { PromiseRejectionEventCoercer } from './coercers/promise-rejection-event'
+import { ErrorPropertiesBuilder } from './error-properties-builder'
+import { ExceptionLike } from './types'
+
+describe('ErrorPropertiesBuilder', () => {
+  describe('coerceUnknown', () => {
+    class CustomTestError extends Error {
+      constructor(message: string, cause?: unknown) {
+        super(message)
+        this.name = 'CustomTestError'
+        this.cause = cause
+      }
+    }
+
+    const errorPropertiesBuilder = new ErrorPropertiesBuilder(
+      [
+        new DOMExceptionCoercer(),
+        new ErrorEventCoercer(),
+        new ErrorCoercer(),
+        new PromiseRejectionEventCoercer(),
+        new ObjectCoercer(),
+        new StringCoercer(),
+        new PrimitiveCoercer(),
+      ],
+      [],
+      []
+    )
+
+    function coerceInput(input: unknown, error: Error = new Error()): ExceptionLike | undefined {
+      const coercingContext = errorPropertiesBuilder.buildCoercingContext(
+        { handled: false },
+        {
+          syntheticException: error,
+        }
+      )
+      return coercingContext.apply(input)
+    }
+
+    it('should handle null values', async () => {
+      const syntheticError = new Error()
+      const exception = coerceInput(null, syntheticError)
+      expect(exception).toMatchObject({
+        type: 'Error',
+        value: 'Primitive value captured as exception: null',
+        stack: syntheticError.stack,
+      })
+    })
+
+    it('should handle string', () => {
+      const syntheticError = new Error()
+      const exception = coerceInput('test', syntheticError)
+      expect(exception).toMatchObject({
+        type: 'Error',
+        value: 'test',
+        stack: syntheticError.stack,
+      })
+    })
+
+    it('should handle exception string', () => {
+      const syntheticError = new Error()
+      const exception = coerceInput('Uncaught exception: InternalError: but somehow still a string', syntheticError)
+      expect(exception).toMatchObject({
+        type: 'InternalError',
+        value: 'but somehow still a string',
+        stack: syntheticError.stack,
+      })
+    })
+
+    it('should use keys in objects', async () => {
+      const syntheticError = new Error()
+      const errorObject = { foo: 'Foo value', bar: 'Bar value' }
+      const exception = coerceInput(errorObject, syntheticError)
+      expect(exception).toMatchObject({
+        type: 'Error',
+        value: 'Object captured as exception with keys: bar, foo',
+        stack: syntheticError.stack,
+      })
+    })
+
+    it('should handle object with an error property', () => {
+      const nestedError = new CustomTestError('My special error')
+      const errorObject = { error: nestedError }
+      const syntheticError = new Error()
+      const exception = coerceInput(errorObject, syntheticError)
+      expect(exception).toMatchObject({
+        type: 'CustomTestError',
+        value: 'My special error',
+        stack: nestedError.stack,
+      })
+    })
+
+    it('should handle error', () => {
+      const errorObject = new CustomTestError('My special error')
+      const exception = coerceInput(errorObject)
+      expect(exception).toMatchObject({
+        type: 'CustomTestError',
+        value: 'My special error',
+        stack: errorObject.stack,
+      })
+    })
+
+    it('should handle error with error cause', () => {
+      const secondError = new CustomTestError('My original error')
+      const firstError = new CustomTestError('My wrapped error', secondError)
+      const exception = coerceInput(firstError)
+      expect(exception).toMatchObject({
+        type: 'CustomTestError',
+        value: 'My wrapped error',
+        stack: firstError.stack,
+        cause: {
+          type: 'CustomTestError',
+          value: 'My original error',
+          stack: secondError.stack,
+        },
+      })
+    })
+
+    it('should handle error with object cause', () => {
+      const originalCause = { foo: 'bar', test: 'test' }
+      const kaboomError = new CustomTestError('Front error', originalCause)
+      const syntheticError = new Error()
+      const exception = coerceInput(kaboomError, syntheticError)
+      expect(exception).toMatchObject({
+        type: 'CustomTestError',
+        value: 'Front error',
+        stack: kaboomError.stack,
+        cause: {
+          type: 'Error',
+          value: 'Object captured as exception with keys: foo, test',
+          // Do we want to use the stack from the synthetic error?
+          stack: undefined,
+        },
+      })
+    })
+
+    it('should handle error with string cause', () => {
+      const originalCause = 'My original error'
+      const kaboomError = new CustomTestError('Front error', originalCause)
+      const syntheticError = new Error()
+      const exception = coerceInput(kaboomError, syntheticError)
+      expect(exception).toMatchObject({
+        type: 'CustomTestError',
+        value: 'Front error',
+        stack: kaboomError.stack,
+        cause: {
+          type: 'Error',
+          value: 'My original error',
+          // Do we want to use the stack from the synthetic error?
+          stack: undefined,
+        },
+      })
+    })
+
+    it('should convert a plain Event to an error', () => {
+      class MouseEvent extends Event {
+        constructor(type: string, eventInitDict?: EventInit) {
+          super(type, eventInitDict)
+        }
+      }
+      const event = new MouseEvent('click', { bubbles: true, cancelable: true, composed: true })
+      const syntheticError = new Error()
+      const exception = coerceInput(event, syntheticError)
+      expect(exception).toMatchObject({
+        type: 'MouseEvent',
+        value: "'MouseEvent' captured as exception with keys: [object has no keys]",
+        stack: syntheticError.stack,
+        synthetic: true,
+      })
+    })
+
+    it('should convert a DOM Error to an error', () => {
+      class FakeDomError {
+        constructor(
+          public name: string,
+          public message: string
+        ) {}
+        [Symbol.toStringTag] = 'DOMError'
+      }
+      const event = new FakeDomError('click', 'foo')
+      const exception = coerceInput(event)
+      expect(exception).toMatchObject({
+        type: 'DOMError',
+        value: 'click: foo',
+        stack: undefined,
+        synthetic: false,
+      })
+    })
+
+    it('should convert a DOM Exception to an error', () => {
+      const event = new DOMException('oh no disaster', 'dom-exception')
+      const exception = coerceInput(event)
+      expect(exception).toBeDefined()
+      expect(exception).toMatchObject({
+        type: 'DOMException',
+        value: 'dom-exception: oh no disaster',
+        synthetic: false,
+      })
+    })
+  })
+})

package/src/error-tracking/error-properties-builder.parse.spec.ts

@@ -0,0 +1,30 @@
+import { ErrorPropertiesBuilder } from './error-properties-builder'
+import { chromeStackLineParser } from './parsers'
+import { StackFrame } from './types'
+
+describe('ErrorPropertiesBuilder', () => {
+  describe('coerceUnknown', () => {
+    const errorPropertiesBuilder = new ErrorPropertiesBuilder([], [chromeStackLineParser], [])
+
+    function parseStack(error: Error): StackFrame[] | undefined {
+      const ctx = {}
+      const exception = errorPropertiesBuilder.parseStacktrace(
+        {
+          type: 'Error',
+          value: 'Whatever',
+          stack: error.stack,
+          synthetic: false,
+        },
+        ctx
+      )
+      return exception.stack
+    }
+
+    it('should parse stacktraces', () => {
+      const syntheticError = new Error()
+      const frames = parseStack(syntheticError)
+      expect(frames).toBeDefined()
+      expect(frames).toHaveLength(16)
+    })
+  })
+})