fix(sentry): discard timed-out onboarding traces instead of sending fake ~5-min durations

When a span is still open after TRACES_CLEANUP_INTERVAL (5 min), the
cleanup timeout now marks it with SpanStatus ERROR / deadline_exceeded
and sets `trace.timed_out = true` before calling end(). The
`excludeEvents` beforeSendTransaction hook drops any event carrying that
flag, so artificially-clamped spans (p50 ≈ 300,014 ms for
"Onboarding - Overall Journey") are never sent to Sentry. Legitimate
long-but-real spans are unaffected because the drop is keyed strictly
on the flag, not on duration.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: smgv

app/util/sentry/utils.test.ts

@@ -249,6 +249,38 @@ describe('excludeEvents', () => {
     expect(result.start_timestamp).toBe(1234567890);
   });
 
+  it('drops event when trace.timed_out flag is true', () => {
+    const event = {
+      transaction: 'Onboarding - Overall Journey',
+      contexts: {
+        trace: {
+          data: {
+            'trace.timed_out': true,
+          },
+        },
+      },
+    };
+
+    const result = excludeEvents(event);
+    expect(result).toBeNull();
+  });
+
+  it('keeps event when trace.timed_out flag is absent', () => {
+    const event = {
+      transaction: 'Onboarding - Overall Journey',
+      contexts: {
+        trace: {
+          data: {
+            'some.other.attr': 'value',
+          },
+        },
+      },
+    };
+
+    const result = excludeEvents(event);
+    expect(result).toBe(event);
+  });
+
   it('returns main-exp for experimental environment and main build type', async () => {
     const METAMASK_ENVIRONMENT = 'exp';
     const isDev = false;

app/util/sentry/utils.ts

@@ -481,6 +481,10 @@ export function excludeEvents(event: SentryEvent | null): SentryEvent | null {
       }
     }
   }
+  if (event?.contexts?.trace?.data?.['trace.timed_out'] === true) {
+    return null;
+  }
+
   //Modify or drop event here
   if (event?.transaction === 'Route Change') {
     //Route change is dropped because is does not reflect a screen we can action on.

app/util/trace.test.ts

@@ -382,7 +382,11 @@ describe('Trace', () => {
       updateCachedConsent(true);
 
       const spanEndMock = jest.fn();
-      const spanMock = { end: spanEndMock } as unknown as Span;
+      const spanMock = {
+        end: spanEndMock,
+        setStatus: jest.fn(),
+        setAttribute: jest.fn(),
+      } as unknown as Span;
 
       startSpanManualMock.mockImplementationOnce((_, fn) =>
         fn(spanMock, () => {
@@ -404,6 +408,41 @@ describe('Trace', () => {
 
       expect(spanEndMock).toHaveBeenCalledTimes(1);
     });
+
+    it('marks span as timed out with deadline_exceeded status when cleanup fires for open span', () => {
+      updateCachedConsent(true);
+
+      const spanEndMock = jest.fn();
+      const setStatusMock = jest.fn();
+      const setAttributeMock = jest.fn();
+      const spanMock = {
+        end: spanEndMock,
+        setStatus: setStatusMock,
+        setAttribute: setAttributeMock,
+      } as unknown as Span;
+
+      startSpanManualMock.mockImplementationOnce((_, fn) =>
+        fn(spanMock, () => {
+          // Intentionally empty
+        }),
+      );
+
+      trace({
+        name: NAME_MOCK,
+        id: ID_MOCK,
+        tags: TAGS_MOCK,
+        data: DATA_MOCK,
+      });
+
+      jest.advanceTimersByTime(TRACES_CLEANUP_INTERVAL);
+
+      expect(setStatusMock).toHaveBeenCalledWith({
+        code: 2,
+        message: 'deadline_exceeded',
+      });
+      expect(setAttributeMock).toHaveBeenCalledWith('trace.timed_out', true);
+      expect(spanEndMock).toHaveBeenCalledTimes(1);
+    });
   });
 
   describe('flushBufferedTraces', () => {

app/util/trace.ts

@@ -732,6 +732,10 @@ function startTrace(request: TraceRequest): TraceContext {
 
     const timeoutId = setTimeout(() => {
       log('Trace cleanup due to timeout', name, id);
+      if (span) {
+        span.setStatus({ code: 2, message: 'deadline_exceeded' });
+        span.setAttribute('trace.timed_out', true);
+      }
       end();
       tracesByKey.delete(getTraceKey(request));
     }, TRACES_CLEANUP_INTERVAL);