fix(analytics): drop unactionable browser noise from error tracking

ResizeObserver loop notices were 92% of everything client-side exception
autocapture reported. They are specified behaviour, not faults — the
observer defers the remaining notifications to the next frame — and they
carry no stack that points anywhere. Alongside opaque cross-origin
"Script error." reports and cancellation signals (fetch AbortError,
Monaco's CancellationError), they bury the handful of real crashes.

Filters them in before_send so they never leave the browser. Fails open
on anything unrecognized: a wrong guess here would delete product
analytics, not just over-report.

Author: icecrasher321

apps/sim/app/_shell/providers/posthog-provider.tsx

@@ -5,6 +5,7 @@ import { createLogger } from '@sim/logger'
 import type { PostHog } from 'posthog-js'
 import { getEnv, isTruthy, publicEnvMissingAtModuleInit } from '@/lib/core/config/env'
 import { settlePostHogClient } from '@/lib/posthog/client'
+import { dropUnactionableExceptions } from '@/lib/posthog/exception-filter'
 
 const logger = createLogger('PostHogProvider')
 
@@ -56,6 +57,14 @@ export function PostHogProvider({ children }: { children: React.ReactNode }) {
               capture_unhandled_rejections: true,
               capture_console_errors: false,
             },
+            /**
+             * Drops the browser artifacts that autocapture cannot help but
+             * see — resize-loop notices, opaque cross-origin failures, and
+             * cancelled requests. Filtering here rather than with a PostHog
+             * suppression rule keeps the list reviewable in the diff and stops
+             * the events before they leave the browser.
+             */
+            before_send: dropUnactionableExceptions,
             disable_session_recording: true,
             session_recording: {
               maskAllInputs: false,

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

@@ -0,0 +1,85 @@
+/**
+ * @vitest-environment node
+ */
+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 {
+  return {
+    uuid: 'test-uuid',
+    event: '$exception',
+    properties: { $exception_list: exceptions },
+  } as CaptureResult
+}
+
+describe('dropUnactionableExceptions', () => {
+  it('passes through events that are not exceptions', () => {
+    const event = {
+      uuid: 'test-uuid',
+      event: 'block_added',
+      properties: { block_type: 'agent' },
+    } as CaptureResult
+
+    expect(dropUnactionableExceptions(event)).toBe(event)
+  })
+
+  it('passes through a null event from an earlier hook', () => {
+    expect(dropUnactionableExceptions(null)).toBeNull()
+  })
+
+  it.each([
+    'ResizeObserver loop completed with undelivered notifications.',
+    'ResizeObserver loop completed with undelivered notifications',
+    'ResizeObserver loop limit exceeded',
+    'Script error.',
+  ])('drops the undiagnosable browser artifact %j', (value) => {
+    expect(dropUnactionableExceptions(exceptionEvent({ type: 'Error', value }))).toBeNull()
+  })
+
+  it.each(['AbortError', 'Canceled'])('drops the cancellation signal %j', (type) => {
+    expect(dropUnactionableExceptions(exceptionEvent({ type, value: 'whatever' }))).toBeNull()
+  })
+
+  it('keeps a real exception', () => {
+    const event = exceptionEvent({
+      type: 'TypeError',
+      value: "Cannot read properties of undefined (reading 'id')",
+    })
+
+    expect(dropUnactionableExceptions(event)).toBe(event)
+  })
+
+  it('keeps a chained exception when only one link is noise', () => {
+    const event = exceptionEvent(
+      { type: 'AbortError', value: 'signal is aborted without reason' },
+      { type: 'RangeError', value: 'Maximum call stack size exceeded.' }
+    )
+
+    expect(dropUnactionableExceptions(event)).toBe(event)
+  })
+
+  it('keeps an exception whose message merely mentions a filtered one', () => {
+    const event = exceptionEvent({
+      type: 'TypeError',
+      value: 'Failed to patch ResizeObserver loop completed with undelivered notifications',
+    })
+
+    expect(dropUnactionableExceptions(event)).toBe(event)
+  })
+
+  it.each([
+    ['a missing list', undefined],
+    ['an empty list', []],
+    ['a non-array list', 'not-an-array'],
+    ['unrecognizable entries', [null, 'string-entry']],
+  ])('fails open on %s', (_label, $exception_list) => {
+    const event = {
+      uuid: 'test-uuid',
+      event: '$exception',
+      properties: { $exception_list },
+    } as CaptureResult
+
+    expect(dropUnactionableExceptions(event)).toBe(event)
+  })
+})

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

@@ -0,0 +1,84 @@
+import type { CaptureResult } from 'posthog-js'
+
+/**
+ * Exception types that only ever mean "something was cancelled".
+ *
+ * `AbortError` is what a fetch rejects with once its `AbortSignal` fires —
+ * React Query aborts in-flight queries on unmount and on refetch, so this is
+ * routine teardown. `Canceled` is Monaco's `CancellationError`
+ * (`monaco-editor/esm/vs/base/common/errors.js` sets both `name` and `message`
+ * to the bare string), raised whenever a language-service request is superseded
+ * by a newer keystroke.
+ *
+ * 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'])
+
+/**
+ * Exception messages that carry no diagnosable content.
+ *
+ * `ResizeObserver loop …` is the browser reporting that a resize callback
+ * dirtied layout again before delivery. It is specified behaviour, not an
+ * error: the observer simply defers the remaining notifications to the next
+ * frame. It has no stack that points anywhere useful and fires constantly in
+ * resizable/canvas UIs — it was 92% of everything captured in the first days of
+ * error tracking. Both the current wording and the older `loop limit exceeded`
+ * spelling are matched.
+ *
+ * `Script error.` is what `window.onerror` reports for a cross-origin script
+ * served without CORS headers. The browser withholds the message, the file, and
+ * the stack, so nothing about it is recoverable.
+ *
+ * Matched by prefix because browsers disagree about the trailing period.
+ */
+const UNDIAGNOSABLE_EXCEPTION_MESSAGES = [
+  'ResizeObserver loop completed with undelivered notifications',
+  'ResizeObserver loop limit exceeded',
+  'Script error.',
+]
+
+interface CapturedException {
+  type?: unknown
+  value?: unknown
+}
+
+function isNoise(exception: CapturedException): boolean {
+  if (typeof exception.type === 'string' && CANCELLATION_EXCEPTION_TYPES.has(exception.type)) {
+    return true
+  }
+
+  if (typeof exception.value !== 'string') return false
+  const message = exception.value.trim()
+
+  return UNDIAGNOSABLE_EXCEPTION_MESSAGES.some((prefix) => message.startsWith(prefix))
+}
+
+/**
+ * `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
+ * untouched. This runs on **every** captured event, so a filter that guessed
+ * wrong would silently delete product analytics rather than merely over-report.
+ *
+ * A chained exception is dropped only when *every* link is noise — one benign
+ * link must not hide a real error it was raised alongside.
+ *
+ * @param event - The event PostHog is about to send, or `null` if an earlier
+ *   hook already dropped it.
+ * @returns The event to send, or `null` to drop it.
+ */
+export function dropUnactionableExceptions(event: CaptureResult | null): CaptureResult | null {
+  if (!event || event.event !== '$exception') return event
+
+  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)
+  )
+
+  return allNoise ? null : event
+}