@posthog/core 1.46.4 → 1.46.5

package/dist/error-tracking/coercers/error-coercer.js

@@ -26,10 +26,10 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     ErrorCoercer: ()=>ErrorCoercer
 });
-const index_js_namespaceObject = require("../../utils/index.js");
+const type_utils_js_namespaceObject = require("../../utils/type-utils.js");
 class ErrorCoercer {
     match(err) {
-        return (0, index_js_namespaceObject.isPlainError)(err);
+        return (0, type_utils_js_namespaceObject.isError)(err);
     }
     coerce(err, ctx) {
         return {

package/dist/error-tracking/coercers/error-coercer.mjs

@@ -1,7 +1,7 @@
-import { isPlainError } from "../../utils/index.mjs";
+import { isError } from "../../utils/type-utils.mjs";
 class ErrorCoercer {
     match(err) {
-        return isPlainError(err);
+        return isError(err);
     }
     coerce(err, ctx) {
         return {

package/dist/error-tracking/coercers/error-event-coercer.d.ts

@@ -7,6 +7,8 @@ export declare class ErrorEventCoercer implements ErrorTrackingCoercer<ErrorEven
     constructor();
     match(err: unknown): err is ErrorEventLike;
     coerce(err: ErrorEventLike, ctx: CoercingContext): ExceptionLike;
+    private _hasUsableMessage;
+    private _buildLocationStack;
 }
 export {};
 //# sourceMappingURL=error-event-coercer.d.ts.map

package/dist/error-tracking/coercers/error-event-coercer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-event-coercer.d.ts","sourceRoot":"","sources":["../../../src/error-tracking/coercers/error-event-coercer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAO/E,UAAU,cAAc;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED,qBAAa,iBAAkB,YAAW,oBAAoB,CAAC,cAAc,CAAC;;IAG5E,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,cAAc;IAI1C,MAAM,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa;CAajE"}
+{"version":3,"file":"error-event-coercer.d.ts","sourceRoot":"","sources":["../../../src/error-tracking/coercers/error-event-coercer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAO/E,UAAU,cAAc;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAQD,qBAAa,iBAAkB,YAAW,oBAAoB,CAAC,cAAc,CAAC;;IAG5E,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,cAAc;IAQ1C,MAAM,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa;IAahE,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,mBAAmB;CAU5B"}

package/dist/error-tracking/coercers/error-event-coercer.js

@@ -30,17 +30,29 @@ const index_js_namespaceObject = require("../../utils/index.js");
 class ErrorEventCoercer {
     constructor(){}
     match(err) {
-        return (0, index_js_namespaceObject.isErrorEvent)(err) && void 0 != err.error;
+        if (!(0, index_js_namespaceObject.isErrorEvent)(err)) return false;
+        const errorEvent = err;
+        return void 0 != errorEvent.error || this._hasUsableMessage(errorEvent);
     }
     coerce(err, ctx) {
-        const exceptionLike = ctx.apply(err.error);
-        if (!exceptionLike) return {
-            type: 'ErrorEvent',
-            value: err.message,
-            stack: ctx.syntheticException?.stack,
+        if (void 0 != err.error) return ctx.apply(err.error);
+        const exceptionLike = ctx.apply(err.message);
+        return {
+            ...exceptionLike,
+            stack: this._buildLocationStack(err) ?? exceptionLike.stack,
             synthetic: true
         };
-        return exceptionLike;
+    }
+    _hasUsableMessage(err) {
+        return (0, index_js_namespaceObject.isString)(err.message) && err.message.length > 0;
+    }
+    _buildLocationStack(err) {
+        const location = err;
+        if ((0, index_js_namespaceObject.isString)(location.filename) && location.filename.length > 0) {
+            const lineno = location.lineno ?? 0;
+            const colno = location.colno ?? 0;
+            return `Error\n    at ${location.filename}:${lineno}:${colno}`;
+        }
     }
 }
 exports.ErrorEventCoercer = __webpack_exports__.ErrorEventCoercer;

package/dist/error-tracking/coercers/error-event-coercer.mjs

@@ -1,18 +1,30 @@
-import { isErrorEvent } from "../../utils/index.mjs";
+import { isErrorEvent, isString } from "../../utils/index.mjs";
 class ErrorEventCoercer {
     constructor(){}
     match(err) {
-        return isErrorEvent(err) && void 0 != err.error;
+        if (!isErrorEvent(err)) return false;
+        const errorEvent = err;
+        return void 0 != errorEvent.error || this._hasUsableMessage(errorEvent);
     }
     coerce(err, ctx) {
-        const exceptionLike = ctx.apply(err.error);
-        if (!exceptionLike) return {
-            type: 'ErrorEvent',
-            value: err.message,
-            stack: ctx.syntheticException?.stack,
+        if (void 0 != err.error) return ctx.apply(err.error);
+        const exceptionLike = ctx.apply(err.message);
+        return {
+            ...exceptionLike,
+            stack: this._buildLocationStack(err) ?? exceptionLike.stack,
             synthetic: true
         };
-        return exceptionLike;
+    }
+    _hasUsableMessage(err) {
+        return isString(err.message) && err.message.length > 0;
+    }
+    _buildLocationStack(err) {
+        const location = err;
+        if (isString(location.filename) && location.filename.length > 0) {
+            const lineno = location.lineno ?? 0;
+            const colno = location.colno ?? 0;
+            return `Error\n    at ${location.filename}:${lineno}:${colno}`;
+        }
     }
 }
 export { ErrorEventCoercer };

package/dist/error-tracking/coercers/object-coercer.d.ts

@@ -6,6 +6,7 @@ export declare class ObjectCoercer implements ErrorTrackingCoercer<ObjectLike> {
     getType(err: Record<string, unknown>): string;
     getValue(err: object): string;
     private isSeverityLevel;
+    private getStack;
     /** If a plain object has a property that is an `Error`, return this error. */
     private getErrorPropertyFromObject;
     private getObjectClassName;

package/dist/error-tracking/coercers/object-coercer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"object-coercer.d.ts","sourceRoot":"","sources":["../../../src/error-tracking/coercers/object-coercer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAiC,MAAM,UAAU,CAAA;AAG9G,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEzC,qBAAa,aAAc,YAAW,oBAAoB,CAAC,UAAU,CAAC;IACpE,KAAK,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,UAAU;IAIlD,MAAM,CAAC,SAAS,EAAE,UAAU,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,GAAG,SAAS;IAe9E,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;IAI7C,QAAQ,CAAC,GAAG,EAAE,MAAM;IAmBpB,OAAO,CAAC,eAAe;IAIvB,8EAA8E;IAC9E,OAAO,CAAC,0BAA0B;IAalC,OAAO,CAAC,kBAAkB;CAQ3B"}
+{"version":3,"file":"object-coercer.d.ts","sourceRoot":"","sources":["../../../src/error-tracking/coercers/object-coercer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAiC,MAAM,UAAU,CAAA;AAG9G,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEzC,qBAAa,aAAc,YAAW,oBAAoB,CAAC,UAAU,CAAC;IACpE,KAAK,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,UAAU;IAIlD,MAAM,CAAC,SAAS,EAAE,UAAU,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,GAAG,SAAS;IAe9E,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;IAI7C,QAAQ,CAAC,GAAG,EAAE,MAAM;IAmBpB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,QAAQ;IAWhB,8EAA8E;IAC9E,OAAO,CAAC,0BAA0B;IAalC,OAAO,CAAC,kBAAkB;CAQ3B"}

package/dist/error-tracking/coercers/object-coercer.js

@@ -39,7 +39,7 @@ class ObjectCoercer {
         return {
             type: this.getType(candidate),
             value: this.getValue(candidate),
-            stack: ctx.syntheticException?.stack,
+            stack: this.getStack(candidate) ?? ctx.syntheticException?.stack,
             level: this.isSeverityLevel(candidate.level) ? candidate.level : 'error',
             synthetic: true
         };
@@ -61,6 +61,14 @@ class ObjectCoercer {
     isSeverityLevel(x) {
         return (0, index_js_namespaceObject.isString)(x) && !(0, index_js_namespaceObject.isEmptyString)(x) && external_types_js_namespaceObject.severityLevels.indexOf(x) >= 0;
     }
+    getStack(candidate) {
+        try {
+            if ((0, index_js_namespaceObject.isString)(candidate.stacktrace) && candidate.stacktrace.length > 0) return candidate.stacktrace;
+            return (0, index_js_namespaceObject.isString)(candidate.stack) && candidate.stack.length > 0 ? candidate.stack : void 0;
+        } catch  {
+            return;
+        }
+    }
     getErrorPropertyFromObject(obj) {
         for(const prop in obj)if (Object.prototype.hasOwnProperty.call(obj, prop)) {
             const value = obj[prop];

package/dist/error-tracking/coercers/object-coercer.mjs

@@ -11,7 +11,7 @@ class ObjectCoercer {
         return {
             type: this.getType(candidate),
             value: this.getValue(candidate),
-            stack: ctx.syntheticException?.stack,
+            stack: this.getStack(candidate) ?? ctx.syntheticException?.stack,
             level: this.isSeverityLevel(candidate.level) ? candidate.level : 'error',
             synthetic: true
         };
@@ -33,6 +33,14 @@ class ObjectCoercer {
     isSeverityLevel(x) {
         return isString(x) && !isEmptyString(x) && severityLevels.indexOf(x) >= 0;
     }
+    getStack(candidate) {
+        try {
+            if (isString(candidate.stacktrace) && candidate.stacktrace.length > 0) return candidate.stacktrace;
+            return isString(candidate.stack) && candidate.stack.length > 0 ? candidate.stack : void 0;
+        } catch  {
+            return;
+        }
+    }
     getErrorPropertyFromObject(obj) {
         for(const prop in obj)if (Object.prototype.hasOwnProperty.call(obj, prop)) {
             const value = obj[prop];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/core",
-  "version": "1.46.4",
+  "version": "1.46.5",
   "bugs": {
     "url": "https://github.com/PostHog/posthog-js/issues"
   },

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

@@ -1,9 +1,9 @@
-import { isPlainError } from '@/utils'
+import { isError } from '@/utils/type-utils'
 import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '../types'
 
 export class ErrorCoercer implements ErrorTrackingCoercer<Error> {
   match(err: unknown): err is Error {
-    return isPlainError(err)
+    return isError(err)
   }
 
   coerce(err: Error, ctx: CoercingContext): ExceptionLike {

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

@@ -0,0 +1,109 @@
+import { ErrorPropertiesBuilder } from '../error-properties-builder'
+import { createDefaultStackParser } from '../parsers'
+import { Exception } from '../types'
+import { ErrorCoercer } from './error-coercer'
+import { ErrorEventCoercer } from './error-event-coercer'
+import { EventCoercer } from './event-coercer'
+import { ObjectCoercer } from './object-coercer'
+import { PrimitiveCoercer } from './primitive-coercer'
+import { StringCoercer } from './string-coercer'
+
+// `ErrorEvent` is not available in the Node test environment, so use its runtime brand.
+class FakeErrorEvent {
+  message?: string
+  error?: unknown
+  filename?: string
+  lineno?: number
+  colno?: number;
+  [Symbol.toStringTag] = 'ErrorEvent'
+
+  constructor(init: Partial<Omit<FakeErrorEvent, typeof Symbol.toStringTag>> = {}) {
+    Object.assign(this, init)
+  }
+}
+
+describe('ErrorEventCoercer', () => {
+  const coercer = new ErrorEventCoercer()
+  const errorPropertiesBuilder = new ErrorPropertiesBuilder(
+    [coercer, new ErrorCoercer(), new EventCoercer(), new ObjectCoercer(), new StringCoercer(), new PrimitiveCoercer()],
+    createDefaultStackParser()
+  )
+
+  function buildException(input: unknown, syntheticException?: Error): Exception {
+    return errorPropertiesBuilder.buildFromUnknown(input, { syntheticException }).$exception_list[0]
+  }
+
+  it.each([
+    {
+      name: 'an ErrorEvent carrying an Error',
+      input: new FakeErrorEvent({ error: new Error('boom') }),
+      expected: true,
+    },
+    {
+      name: 'an ErrorEvent carrying a message',
+      input: new FakeErrorEvent({ message: 'Script error.' }),
+      expected: true,
+    },
+    { name: 'an ErrorEvent without an error or message', input: new FakeErrorEvent(), expected: false },
+    { name: 'an ErrorEvent with an empty message', input: new FakeErrorEvent({ message: '' }), expected: false },
+    { name: 'a non-ErrorEvent', input: { message: 'not an ErrorEvent' }, expected: false },
+  ])('matches $name: $expected', ({ input, expected }) => {
+    expect(coercer.match(input)).toBe(expected)
+  })
+
+  it('unwraps the Error carried by the ErrorEvent', () => {
+    const error = new Error('Something broke')
+    error.name = 'CustomTestError'
+
+    expect(buildException(new FakeErrorEvent({ message: 'ignored', error }))).toMatchObject({
+      type: 'CustomTestError',
+      value: 'Something broke',
+      mechanism: { synthetic: false },
+    })
+  })
+
+  it('preserves the message and location when there is no Error object', () => {
+    const exception = buildException(
+      new FakeErrorEvent({
+        message: 'Uncaught TypeError: x is not a function',
+        filename: 'https://example.com/app.js',
+        lineno: 42,
+        colno: 13,
+      })
+    )
+
+    expect(exception).toMatchObject({
+      type: 'TypeError',
+      value: 'x is not a function',
+      mechanism: { synthetic: true },
+      stacktrace: {
+        frames: [
+          expect.objectContaining({
+            filename: 'https://example.com/app.js',
+            lineno: 42,
+            colno: 13,
+          }),
+        ],
+      },
+    })
+  })
+
+  it('does not parse frame-shaped lines from a multiline message', () => {
+    const exception = buildException(
+      new FakeErrorEvent({
+        message: 'Something broke\n    at injected (https://example.com/injected.js:1:2)',
+        filename: 'https://example.com/app.js',
+        lineno: 42,
+        colno: 13,
+      })
+    )
+
+    expect(exception.stacktrace?.frames).toEqual([
+      expect.objectContaining({
+        filename: 'https://example.com/app.js',
+        lineno: 42,
+        colno: 13,
+      }),
+    ])
+  })
+})

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

@@ -1,5 +1,5 @@
 import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '../types'
-import { isErrorEvent } from '@/utils'
+import { isErrorEvent, isString } from '@/utils'
 
 // Structural subset of the DOM `ErrorEvent`. Avoids leaking a DOM-only global
 // into the public type surface so non-DOM consumers (e.g. React Native, whose
@@ -10,24 +10,48 @@ interface ErrorEventLike {
   error?: unknown
 }
 
+interface ErrorEventLocation {
+  filename?: string
+  lineno?: number
+  colno?: number
+}
+
 export class ErrorEventCoercer implements ErrorTrackingCoercer<ErrorEventLike> {
   constructor() {}
 
   match(err: unknown): err is ErrorEventLike {
-    return isErrorEvent(err) && (err as ErrorEventLike).error != undefined
+    if (!isErrorEvent(err)) {
+      return false
+    }
+    const errorEvent = err as ErrorEventLike
+    return errorEvent.error != undefined || this._hasUsableMessage(errorEvent)
   }
 
   coerce(err: ErrorEventLike, ctx: CoercingContext): ExceptionLike {
-    const exceptionLike = ctx.apply(err.error)
-    if (!exceptionLike) {
-      return {
-        type: 'ErrorEvent',
-        value: err.message,
-        stack: ctx.syntheticException?.stack,
-        synthetic: true,
-      }
-    } else {
-      return exceptionLike
+    if (err.error != undefined) {
+      return ctx.apply(err.error)
+    }
+
+    const exceptionLike = ctx.apply(err.message)
+    return {
+      ...exceptionLike,
+      stack: this._buildLocationStack(err) ?? exceptionLike.stack,
+      synthetic: true,
+    }
+  }
+
+  private _hasUsableMessage(err: ErrorEventLike): boolean {
+    return isString(err.message) && err.message.length > 0
+  }
+
+  private _buildLocationStack(err: ErrorEventLike): string | undefined {
+    const location = err as ErrorEventLike & ErrorEventLocation
+    if (isString(location.filename) && location.filename.length > 0) {
+      const lineno = location.lineno ?? 0
+      const colno = location.colno ?? 0
+      // The message stays in `value`, which prevents multiline messages from being parsed as extra frames.
+      return `Error\n    at ${location.filename}:${lineno}:${colno}`
     }
+    return undefined
   }
 }

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

@@ -21,7 +21,7 @@ export class ObjectCoercer implements ErrorTrackingCoercer<ObjectLike> {
       return {
         type: this.getType(candidate),
         value: this.getValue(candidate),
-        stack: ctx.syntheticException?.stack,
+        stack: this.getStack(candidate) ?? ctx.syntheticException?.stack,
         level: this.isSeverityLevel(candidate.level) ? candidate.level : 'error',
         synthetic: true,
       }
@@ -55,6 +55,17 @@ export class ObjectCoercer implements ErrorTrackingCoercer<ObjectLike> {
     return isString(x) && !isEmptyString(x) && severityLevels.indexOf(x as SeverityLevel) >= 0
   }
 
+  private getStack(candidate: ObjectLike): string | undefined {
+    try {
+      if (isString(candidate.stacktrace) && candidate.stacktrace.length > 0) {
+        return candidate.stacktrace
+      }
+      return isString(candidate.stack) && candidate.stack.length > 0 ? candidate.stack : undefined
+    } catch {
+      return undefined
+    }
+  }
+
   /** 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) {

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

@@ -1,3 +1,5 @@
+import { runInNewContext } from 'node:vm'
+
 import {
   DOMExceptionCoercer,
   ErrorEventCoercer,
@@ -110,6 +112,28 @@ describe('ErrorPropertiesBuilder', () => {
       })
     })
 
+    it('should preserve a cross-realm error', () => {
+      const crossRealmError = runInNewContext(
+        `new TypeError('cross-realm error', {
+          cause: new Error('cross-realm cause')
+        })`
+      )
+      expect(crossRealmError).not.toBeInstanceOf(Error)
+
+      expect(coerceInput(crossRealmError)).toMatchObject({
+        type: 'TypeError',
+        value: 'cross-realm error',
+        stack: crossRealmError.stack,
+        synthetic: false,
+        cause: {
+          type: 'Error',
+          value: 'cross-realm cause',
+          stack: crossRealmError.cause.stack,
+          synthetic: false,
+        },
+      })
+    })
+
     it('should handle error with error cause', () => {
       const secondError = new CustomTestError('My original error')
       const firstError = new CustomTestError('My wrapped error', secondError)
@@ -225,5 +249,23 @@ describe('ErrorPropertiesBuilder', () => {
         stack: buriedError.stack,
       })
     })
+
+    it('should preserve an error-like stack from a CustomEvent wrapping a PromiseRejectionEvent', () => {
+      const stack = 'TypeError: Extension context invalidated.\n    at extension.js:1:2'
+      const customEvent = new CustomEvent('unhandledrejection', {
+        detail: {
+          reason: {
+            name: 'TypeError',
+            message: 'Extension context invalidated.',
+            stack,
+          },
+        },
+      })
+
+      expect(coerceInput(customEvent)).toMatchObject({
+        value: "'TypeError' captured as exception with message: 'Extension context invalidated.'",
+        stack,
+      })
+    })
   })
 })