fix(analytics): match cancellations on error name, not coerced type

Two holes in the exception filter, both found reading PostHog's coercers
rather than trusting the shape.

The DOMException coercer always reports type "DOMException" and folds the
name into the value as "AbortError: signal is aborted without reason", so
matching AbortError on type alone never fired for a real aborted fetch —
the filter was dead code for exactly the events it was written for. Match
the error name wherever the coercer put it.

The filter also applied to deliberate captureException reports, which our
error boundaries make. Only exceptions the browser raised itself
(mechanism.handled === false) are now eligible; a report we chose to send
is never dropped.

Author: icecrasher321

apps/sim/lib/posthog/exception-filter.test.ts

@@ -5,11 +5,34 @@ import type { CaptureResult } from 'posthog-js'
 import { describe, expect, it } from 'vitest'
 import { dropUnactionableExceptions } from '@/lib/posthog/exception-filter'
 
-function exceptionEvent(...exceptions: Array<{ type?: string; value?: string }>): CaptureResult {
+interface TestException {
+  type?: string
+  value?: string
+  mechanism?: { handled?: boolean }
+}
+
+/** Mirrors what PostHog's `window.onerror` / `unhandledrejection` wrappers build. */
+function browserRaised(...exceptions: TestException[]): CaptureResult {
+  const [head, ...rest] = exceptions
+  return {
+    uuid: 'test-uuid',
+    event: '$exception',
+    properties: {
+      $exception_list: [
+        { ...head, mechanism: { handled: false } },
+        // PostHog forces chained cause links to handled: true regardless of the source.
+        ...rest.map((exception) => ({ ...exception, mechanism: { handled: true } })),
+      ],
+    },
+  } as CaptureResult
+}
+
+/** Mirrors what `posthog.captureException` builds — a deliberate report. */
+function deliberatelyReported(exception: TestException): CaptureResult {
   return {
     uuid: 'test-uuid',
     event: '$exception',
-    properties: { $exception_list: exceptions },
+    properties: { $exception_list: [{ ...exception, mechanism: { handled: true } }] },
   } as CaptureResult
 }
 
@@ -34,24 +57,60 @@ describe('dropUnactionableExceptions', () => {
     'ResizeObserver loop limit exceeded',
     'Script error.',
   ])('drops the undiagnosable browser artifact %j', (value) => {
-    expect(dropUnactionableExceptions(exceptionEvent({ type: 'Error', value }))).toBeNull()
+    expect(dropUnactionableExceptions(browserRaised({ type: 'Error', value }))).toBeNull()
+  })
+
+  it('drops a cancellation whose name is the coerced type', () => {
+    expect(
+      dropUnactionableExceptions(browserRaised({ type: 'Canceled', value: 'Canceled' }))
+    ).toBeNull()
   })
 
-  it.each(['AbortError', 'Canceled'])('drops the cancellation signal %j', (type) => {
-    expect(dropUnactionableExceptions(exceptionEvent({ type, value: 'whatever' }))).toBeNull()
+  /**
+   * The shape a real aborted `fetch` produces: PostHog's DOMException coercer
+   * reports type `DOMException` and folds the name into the value, so a filter
+   * that only tested `type` would let every one of these through.
+   */
+  it('drops a cancellation whose name is folded into a DOMException value', () => {
+    expect(
+      dropUnactionableExceptions(
+        browserRaised({
+          type: 'DOMException',
+          value: 'AbortError: signal is aborted without reason',
+        })
+      )
+    ).toBeNull()
+  })
+
+  it('keeps a DOMException that is not a cancellation', () => {
+    const event = browserRaised({
+      type: 'DOMException',
+      value: "NotFoundError: Failed to execute 'removeChild' on 'Node'",
+    })
+
+    expect(dropUnactionableExceptions(event)).toBe(event)
   })
 
   it('keeps a real exception', () => {
-    const event = exceptionEvent({
+    const event = browserRaised({
       type: 'TypeError',
       value: "Cannot read properties of undefined (reading 'id')",
     })
 
     expect(dropUnactionableExceptions(event)).toBe(event)
   })
 
+  it('keeps a deliberately reported exception even when it looks like noise', () => {
+    const event = deliberatelyReported({
+      type: 'AbortError',
+      value: 'signal is aborted without reason',
+    })
+
+    expect(dropUnactionableExceptions(event)).toBe(event)
+  })
+
   it('keeps a chained exception when only one link is noise', () => {
-    const event = exceptionEvent(
+    const event = browserRaised(
       { type: 'AbortError', value: 'signal is aborted without reason' },
       { type: 'RangeError', value: 'Maximum call stack size exceeded.' }
     )
@@ -60,7 +119,7 @@ describe('dropUnactionableExceptions', () => {
   })
 
   it('keeps an exception whose message merely mentions a filtered one', () => {
-    const event = exceptionEvent({
+    const event = browserRaised({
       type: 'TypeError',
       value: 'Failed to patch ResizeObserver loop completed with undelivered notifications',
     })

apps/sim/lib/posthog/exception-filter.ts

@@ -13,7 +13,7 @@ import type { CaptureResult } from 'posthog-js'
  * Neither can be acted on: there is no defect to fix and no user impact, but
  * both fire often enough per session to bury real crashes in the issue list.
  */
-const CANCELLATION_EXCEPTION_TYPES = new Set(['AbortError', 'Canceled'])
+const CANCELLATION_ERROR_NAMES = new Set(['AbortError', 'Canceled'])
 
 /**
  * Exception messages that carry no diagnosable content.
@@ -41,13 +41,50 @@ const UNDIAGNOSABLE_EXCEPTION_MESSAGES = [
 interface CapturedException {
   type?: unknown
   value?: unknown
+  mechanism?: { handled?: unknown }
 }
 
-function isNoise(exception: CapturedException): boolean {
-  if (typeof exception.type === 'string' && CANCELLATION_EXCEPTION_TYPES.has(exception.type)) {
+/**
+ * Whether the browser raised this itself, rather than us reporting it on purpose.
+ *
+ * PostHog's `window.onerror` and `unhandledrejection` wrappers both build their
+ * exception with `mechanism.handled: false`, while `captureException` — the call
+ * our error boundaries make — builds with `true`. Only the browser's own reports
+ * are eligible for filtering: a deliberate report means someone decided the
+ * failure was worth knowing about, and dropping it would repeat the silent loss
+ * this filter's sibling gate exists to prevent.
+ *
+ * Read from the first entry only. When an error carries a `cause`, PostHog
+ * appends the chained links with `handled: true` regardless of how the original
+ * was raised, so the head of the list is the one that reflects the source.
+ */
+function isBrowserRaised(exceptions: CapturedException[]): boolean {
+  return exceptions[0]?.mechanism?.handled === false
+}
+
+/**
+ * Whether this is a cancellation, testing both shapes PostHog can produce.
+ *
+ * Which field carries the error's `name` depends on which coercer ran. A plain
+ * `Error` keeps its `name` as `type`, so Monaco's `CancellationError` arrives as
+ * type `Canceled`. A `DOMException` — what `fetch` rejects with when its signal
+ * fires — always coerces to type `DOMException`, with the name folded into the
+ * front of the value as `"AbortError: signal is aborted without reason"`.
+ * Matching on `type` alone therefore misses every real aborted request.
+ */
+function isCancellation(exception: CapturedException): boolean {
+  if (typeof exception.type === 'string' && CANCELLATION_ERROR_NAMES.has(exception.type)) {
     return true
   }
 
+  if (typeof exception.value !== 'string') return false
+
+  return CANCELLATION_ERROR_NAMES.has(exception.value.split(':', 1)[0])
+}
+
+function isNoise(exception: CapturedException): boolean {
+  if (isCancellation(exception)) return true
+
   if (typeof exception.value !== 'string') return false
   const message = exception.value.trim()
 
@@ -57,8 +94,9 @@ function isNoise(exception: CapturedException): boolean {
 /**
  * `before_send` hook that drops browser noise from error tracking.
  *
- * Fails open in every direction: anything that is not a `$exception`, and any
- * `$exception` whose list is missing or unrecognizable, passes through
+ * Fails open in every direction: anything that is not a `$exception`, any
+ * `$exception` whose list is missing or unrecognizable, and anything we
+ * reported deliberately rather than caught from the browser, all pass through
  * untouched. This runs on **every** captured event, so a filter that guessed
  * wrong would silently delete product analytics rather than merely over-report.
  *
@@ -75,10 +113,13 @@ export function dropUnactionableExceptions(event: CaptureResult | null): Capture
   const exceptions: unknown = event.properties?.$exception_list
   if (!Array.isArray(exceptions) || exceptions.length === 0) return event
 
-  const allNoise = exceptions.every(
-    (exception) =>
-      typeof exception === 'object' && exception !== null && isNoise(exception as CapturedException)
+  const entries: CapturedException[] = exceptions.filter(
+    (exception): exception is CapturedException =>
+      typeof exception === 'object' && exception !== null
   )
+  if (entries.length !== exceptions.length) return event
+
+  if (!isBrowserRaised(entries)) return event
 
-  return allNoise ? null : event
+  return entries.every(isNoise) ? null : event
 }