The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
fix(studio): initialize Sentry on the TanStack build (captures were silent no-ops) (#47666)
Alaister Young74bc0a8e270d
diff --git a/apps/studio/.github/eslint-rule-baselines.json b/apps/studio/.github/eslint-rule-baselines.jsonindex 5926095fa21..3257114252d 100644--- a/apps/studio/.github/eslint-rule-baselines.json+++ b/apps/studio/.github/eslint-rule-baselines.json@@ -3,7 +3,7 @@"react-hooks/exhaustive-deps": 161,"import/no-anonymous-default-export": 57,"@tanstack/query/exhaustive-deps": 9,- "@typescript-eslint/no-explicit-any": 898,+ "@typescript-eslint/no-explicit-any": 897,"no-restricted-imports": 0,"no-restricted-exports": 198,"react/no-unstable-nested-components": 38,@@ -556,7 +556,6 @@"hooks/misc/withAuth.tsx": 1,"hooks/ui/useClickedOutside.ts": 2,"hooks/ui/useFlag.ts": 1,- "instrumentation-client.ts": 3,"lib/ai/generate-assistant-response.ts": 2,"lib/ai/model.ts": 2,"lib/ai/model.utils.ts": 3,@@ -571,6 +570,7 @@"lib/pg-format.ts": 6,"lib/profile.tsx": 1,"lib/role-impersonation.ts": 1,+ "lib/sentry-client-options.ts": 2,"lib/telemetry/track.ts": 1,"pages/_app.tsx": 1,"pages/api/ai/feedback/rate.ts": 2,diff --git a/apps/studio/instrumentation-client.ts b/apps/studio/instrumentation-client.tsindex 0097516a418..132068af7e9 100644--- a/apps/studio/instrumentation-client.ts+++ b/apps/studio/instrumentation-client.ts@@ -1,314 +1,22 @@-// This file configures the initialization of Sentry on the client.-// The config you add here will be used whenever a user loads a page in their browser.+// This file configures the initialization of Sentry on the client for the+// NEXT build — Next auto-loads it whenever a user loads a page in their+// browser. The TanStack Start (Vite) build never loads Next convention files;+// it initializes Sentry with the same shared options in+// sentry.tanstack.ts instead.// https://docs.sentry.io/platforms/javascript/guides/nextjs/import * as Sentry from '@sentry/nextjs'-import { hasConsented } from 'common'-import { IS_PLATFORM } from 'common/constants/environment'-import { MIRRORED_BREADCRUMBS } from '@/lib/breadcrumbs'-import { sanitizeArrayOfObjects, sanitizeUrlHashParams } from '@/lib/sanitize'+import { buildSentryClientOptions } from '@/lib/sentry-client-options'-const DEFAULT_ERROR_SAMPLE_RATE = 1.0-const LOW_PRIORITY_ERROR_SAMPLE_RATE = 0.01-const CHUNK_LOAD_ERROR_PATTERNS = [- /ChunkLoadError/i,- /Loading chunk [\d]+ failed/i,- /Loading CSS chunk [\d]+ failed/i,-]--// This is a workaround to ignore hCaptcha related errors.-function isHCaptchaRelatedError(event: Sentry.Event): boolean {- const errors = event.exception?.values ?? []- for (const error of errors) {- if (- error.value?.includes('is not a function') &&- error.stacktrace?.frames?.some((f) => f.filename === 'api.js')- ) {- return true- }- }- return false-}--// Filter browser wallet extension errors (e.g., Gate.io wallet)-// These errors come from injected wallet scripts and are not actionable-// Examples: SUPABASE-APP-AFC, SUPABASE-APP-92A-export function isBrowserWalletExtensionError(event: Sentry.Event): boolean {- const frames = event.exception?.values?.flatMap((e) => e.stacktrace?.frames || []) || []- return frames.some((frame) => {- const filename = frame.filename || frame.abs_path || ''- return filename.includes('gt-window-provider') || filename.includes('wallet-provider')+Sentry.init(+ buildSentryClientOptions({+ // next.config.ts (withSentryConfig) annotates the bundles with the+ // 'supabase-studio' applicationKey, so third-party frame tagging works+ // on this build.+ includeThirdPartyErrorFilter: true,})-}--// Filter user-aborted operations (intentional cancellations)-// These are expected when users cancel requests or navigate away-// Examples: SUPABASE-APP-BG6, SUPABASE-APP-BG7-export function isUserAbortedOperation(error: unknown, event: Sentry.Event): boolean {- const errorMessage = error instanceof Error ? error.message : ''- const eventMessage = event.message || ''- const message = errorMessage || eventMessage-- return (- message.includes('operation was aborted') ||- message.includes('signal is aborted') ||- message.includes('manually canceled') ||- message.includes('AbortError')- )-}--// Filter cancellation promise rejections (e.g., from query cancellation)-// These occur when operations are intentionally cancelled by the user-// Example: SUPABASE-APP-353 (~466k events)-export function isCancellationRejection(event: Sentry.Event): boolean {- const serialized = event.extra?.__serialized__ as Record<string, unknown> | undefined- return serialized?.type === 'cancelation'-}--// Filter challenge/captcha expired errors (user timeout)-// These happen when users don't complete captcha in time - expected behavior-// Example: SUPABASE-APP-ACC-export function isChallengeExpiredError(error: unknown, event: Sentry.Event): boolean {- const errorMessage = error instanceof Error ? error.message : ''- const eventMessage = event.message || ''- const message = errorMessage || eventMessage-- return message.includes('challenge-expired')-}--function isChunkLoadError(error: unknown, event: Sentry.Event): boolean {- const errorMessage = error instanceof Error ? error.message : ''- const eventMessage = event.message || ''- const exceptionMessages = event.exception?.values?.map((ex) => ex.value ?? '') ?? []- const combinedMessages = [errorMessage, eventMessage, ...exceptionMessages].filter(Boolean)-- return CHUNK_LOAD_ERROR_PATTERNS.some((pattern) =>- combinedMessages.some((message) => pattern.test(message))- )-}--Sentry.init({- dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,- ...(process.env.NEXT_PUBLIC_SENTRY_ENVIRONMENT && {- environment: process.env.NEXT_PUBLIC_SENTRY_ENVIRONMENT,- }),- // Setting this option to true will print useful information to the console while you're setting up Sentry.- debug: false,-- // Enable performance monitoring- tracesSampleRate: 0.02,-- integrations: (() => {- const thirdPartyErrorFilterIntegration = (Sentry as any).thirdPartyErrorFilterIntegration- if (!thirdPartyErrorFilterIntegration) return []-- // Tag errors whose stack trace only contains third-party frames (browser extensions,- // injected scripts, etc.). This uses build-time code annotation via the applicationKey- // in next.config.ts to reliably distinguish our code from third-party code.- // We use 'apply-tag' instead of 'drop' so that beforeSend can exempt error boundary- // crashes — these may originate in third-party code but are caused by first-party bugs.- return [- thirdPartyErrorFilterIntegration({- filterKeys: ['supabase-studio'],- behaviour: 'apply-tag-if-exclusively-contains-third-party-frames',- }),- ]- })(),-- // Only capture errors originating from our own code.- // This is a whitelist on the source URL in stack frames — it drops errors from- // browser extensions, injected scripts, third-party widgets, etc. (FE-2094)- allowUrls: [- /https?:\/\/(.*\.)?supabase\.(com|co|green|io)/,- /app:\/\//, // Next.js rewrites source URLs to app:// with source maps- ],- beforeBreadcrumb(breadcrumb, _hint) {- const cleanedBreadcrumb = { ...breadcrumb }-- if (cleanedBreadcrumb.category === 'navigation') {- if (typeof cleanedBreadcrumb.data?.from === 'string') {- cleanedBreadcrumb.data.from = sanitizeUrlHashParams(cleanedBreadcrumb.data.from)- }- if (typeof cleanedBreadcrumb.data?.to === 'string') {- cleanedBreadcrumb.data.to = sanitizeUrlHashParams(cleanedBreadcrumb.data.to)- }- }-- MIRRORED_BREADCRUMBS.pushBack(cleanedBreadcrumb)- return cleanedBreadcrumb- },- beforeSend(event, hint) {- const consent = hasConsented()-- if (!consent) {- return null- }-- if (!IS_PLATFORM) {- return null- }-- const isErrorBoundaryCrash =- event.tags?.globalErrorBoundary === true || event.tags?.globalErrorBoundary === 'true'- const isThirdPartyOnly =- event.tags?.third_party_code === true || event.tags?.third_party_code === 'true'-- // Drop third-party-only errors UNLESS they crashed the page via the global error boundary.- // This preserves noise reduction for browser extensions and injected scripts,- // while ensuring page-crashing errors from third-party libs (caused by first-party bugs)- // are always reported.- if (isThirdPartyOnly && !isErrorBoundaryCrash) {- return null- }-- // Downsample only known high-noise classes; keep all other errors at full rate.- const isInvalidUrlEvent = (hint.originalException as any)?.message?.includes(- `Failed to construct 'URL': Invalid URL`- )- const isSessionTimeoutEvent = (hint.originalException as any)?.message?.includes(- 'Session error detected'- )- const isChunkLoadFailure = isChunkLoadError(hint.originalException, event)-- const codeSampleRate =- isInvalidUrlEvent || isSessionTimeoutEvent || isChunkLoadFailure- ? LOW_PRIORITY_ERROR_SAMPLE_RATE- : DEFAULT_ERROR_SAMPLE_RATE-- if (Math.random() > codeSampleRate) {- return null- }-- event.tags = {- ...event.tags,- codeSampleRate: codeSampleRate.toString(),- }-- if (isHCaptchaRelatedError(event)) {- return null- }-- // Drop events where every exception has no stack trace — these are not debuggable.- // Exempt error boundary crashes: even without stack frames, a page crash is always worth reporting.- const exceptions = event.exception?.values ?? []- if (- !isErrorBoundaryCrash &&- exceptions.length > 0 &&- exceptions.every((ex) => !ex.stacktrace?.frames?.length)- ) {- return null- }-- // Filter out errors like 'e._5BLbSXV[t] is not a function' or anything matching '[t] is not a function'- if (- hint.originalException instanceof Error &&- hint.originalException.message.includes('[t] is not a function')- ) {- return null- }-- if (isBrowserWalletExtensionError(event)) {- return null- }- if (isUserAbortedOperation(hint.originalException, event)) {- return null- }- if (isCancellationRejection(event)) {- return null- }- if (isChallengeExpiredError(hint.originalException, event)) {- return null- }-- if (event.breadcrumbs) {- event.breadcrumbs = sanitizeArrayOfObjects(event.breadcrumbs) as Sentry.Breadcrumb[]- }- return event- },- ignoreErrors: [- // === Monaco Editor ===- 'ResizeObserver',- 's.getModifierState is not a function',- /^Uncaught NetworkError: Failed to execute 'importScripts' on 'WorkerGlobalScope'/,-- // === Browser extension errors ===- // Gate.io wallet- 'shouldSetTallyForCurrentProvider is not a function',- // SAP browser extensions (SAP GUI, SAP Companion)- 'sap is not defined',- // Non-Error objects thrown as exceptions (e.g., Event objects)- '[object Event]',-- // === Third-party SDK errors ===- // stripe-js: https://github.com/stripe/stripe-js/issues/26- 'Failed to load Stripe.js',- // hCaptcha- "undefined is not an object (evaluating 'n.chat.setReady')",- "undefined is not an object (evaluating 'i.chat.setReady')",-- // === Next.js internals ===- // Ref: https://github.com/supabase/supabase/pull/9729- /The provided `href` \(\/org\/\[slug\]\/.*\) value is missing query values/,- // Next.js throws these during navigation, not actual errors- 'NEXT_NOT_FOUND',- 'NEXT_REDIRECT',-- // === User input errors (not bugs) ===- // sql-formatter lexer on invalid SQL input- /^Parse error: Unexpected ".+" at line \d+ column \d+$/,-- // === Network / infrastructure (not actionable on FE) ===- /504 Gateway Time-out/,- 'Network request failed',- 'Failed to fetch',- 'Load failed',- 'AbortError',- 'TypeError: cancelled',- 'TypeError: Cancelled',-- // === Browser extensions & Google Translate DOM manipulation ===- 'Node.insertBefore: Child to insert before is not a child of this node',- 'Node.removeChild: The node to be removed is not a child of this node',- "NotFoundError: Failed to execute 'removeChild' on 'Node'",- "NotFoundError: Failed to execute 'insertBefore' on 'Node'",- 'NotFoundError: The object can not be found here.',- "Cannot read properties of null (reading 'parentNode')",- "Cannot read properties of null (reading 'removeChild')",- "TypeError: can't access dead object",- /^NS_ERROR_/,-- // === Non-Error throws (extensions, third-party libs throwing strings/objects) ===- 'Non-Error exception captured',- 'Non-Error promise rejection captured',- /^Object captured as exception with keys:/,-- // === Cross-origin script errors (no useful info) ===- 'Script error.',- 'Script error',-- // === React hydration mismatches caused by extensions modifying DOM ===- // Note: we only suppress the generic browser messages, NOT "Hydration failed because..."- // which can indicate real SSR/client mismatches in our own code.- /text content does not match/i,- /There was an error while hydrating/i,-- // === Web crawler / bot errors ===- 'instantSearchSDKJSBridgeClearHighlight',-- // === Third-party library race conditions ===- // cmdk: useSyncExternalStore subscribe called before store context is available- "Cannot read properties of undefined (reading 'subscribe')",- "undefined is not an object (evaluating 't.subscribe')",-- // === Misc known noise ===- 'r.default.setDefaultLevel is not a function',- // Clipboard permission denied- 'The request is not allowed by the user agent or the platform in the current context, possibly because the user denied permission.',- // Facebook pixel- 'fb_xd_fragment',- ],-})+)// This export will instrument router navigations, and is only relevant if you enable tracing.export const onRouterTransitionStart = Sentry.captureRouterTransitionStartdiff --git a/apps/studio/instrumentation-client.test.ts b/apps/studio/lib/sentry-client-options.test.tssimilarity index 77%rename from apps/studio/instrumentation-client.test.tsrename to apps/studio/lib/sentry-client-options.test.tsindex c8f5d1aab13..74732c21557 100644--- a/apps/studio/instrumentation-client.test.ts+++ b/apps/studio/lib/sentry-client-options.test.ts@@ -1,12 +1,13 @@-import type { Event as SentryEvent, StackFrame } from '@sentry/nextjs'+import type { Event as SentryEvent, StackFrame } from '@sentry/react'import { describe, expect, it } from 'vitest'import {+ buildSentryClientOptions,isBrowserWalletExtensionError,isCancellationRejection,isChallengeExpiredError,isUserAbortedOperation,-} from './instrumentation-client'+} from './sentry-client-options'describe('Sentry beforeSend filtering functions', () => {describe('isBrowserWalletExtensionError', () => {@@ -417,3 +418,80 @@ describe('Sentry beforeSend filtering functions', () => {})})})++describe('buildSentryClientOptions', () => {+ // Representative subset of Sentry's default integrations. `integrations`+ // is the function form: Sentry.init calls it with the defaults and installs+ // whatever it returns, so dropping these here would disable session+ // envelopes (BrowserSession) and window.onerror capture (GlobalHandlers).+ const fakeDefaultIntegrations = [{ name: 'BrowserSession' }, { name: 'GlobalHandlers' }]++ const getIntegrationNames = (options: ReturnType<typeof buildSentryClientOptions>) => {+ const integrations = options.integrations+ if (typeof integrations !== 'function') {+ throw new Error('expected the function form of integrations')+ }+ return integrations(fakeDefaultIntegrations).map((integration) => integration.name)+ }++ it('preserves the default integrations passed in by Sentry.init', () => {+ for (const includeThirdPartyErrorFilter of [true, false]) {+ const names = getIntegrationNames(buildSentryClientOptions({ includeThirdPartyErrorFilter }))+ // browserSessionIntegration is what sends the session envelope on every+ // page load; globalHandlers is window.onerror / unhandledrejection.+ expect(names).toContain('BrowserSession')+ expect(names).toContain('GlobalHandlers')+ }+ })++ it('sets the release only when one is provided', () => {+ const withRelease = buildSentryClientOptions({+ includeThirdPartyErrorFilter: false,+ release: 'abc123',+ })+ expect(withRelease.release).toBe('abc123')++ // The key must be ABSENT when no release is passed: on the Next build a+ // `release: undefined` entry would override the release injected into+ // @sentry/nextjs's init by withSentryConfig (options are spread last).+ const withoutRelease = buildSentryClientOptions({ includeThirdPartyErrorFilter: true })+ expect('release' in withoutRelease).toBe(false)+ })++ it('includes the third-party error filter only when the build annotates frames', () => {+ // Next build: withSentryConfig injects the applicationKey metadata.+ expect(+ getIntegrationNames(buildSentryClientOptions({ includeThirdPartyErrorFilter: true }))+ ).toContain('ThirdPartyErrorsFilter')++ // TanStack/Vite build: no bundler metadata — including the integration+ // would tag every event third_party_code=true and beforeSend would drop+ // them all.+ expect(+ getIntegrationNames(buildSentryClientOptions({ includeThirdPartyErrorFilter: false }))+ ).not.toContain('ThirdPartyErrorsFilter')+ })++ it('appends build-specific extra integrations', () => {+ const options = buildSentryClientOptions({+ includeThirdPartyErrorFilter: false,+ extraIntegrations: [{ name: 'FakeRouterTracing' }],+ })++ expect(getIntegrationNames(options)).toContain('FakeRouterTracing')+ })++ it('builds the same shared options for both builds (parity)', () => {+ const nextOptions = buildSentryClientOptions({ includeThirdPartyErrorFilter: true })+ const tanstackOptions = buildSentryClientOptions({ includeThirdPartyErrorFilter: false })++ // Everything except the integrations array must be identical between the+ // two runtimes.+ const { integrations: _next, ...nextRest } = nextOptions+ const { integrations: _tanstack, ...tanstackRest } = tanstackOptions+ expect(Object.keys(nextRest)).toEqual(Object.keys(tanstackRest))+ expect(nextRest.tracesSampleRate).toBe(tanstackRest.tracesSampleRate)+ expect(nextRest.allowUrls).toEqual(tanstackRest.allowUrls)+ expect(nextRest.ignoreErrors).toEqual(tanstackRest.ignoreErrors)+ })+})diff --git a/apps/studio/lib/sentry-client-options.ts b/apps/studio/lib/sentry-client-options.tsnew file mode 100644index 00000000000..693f01021df--- /dev/null+++ b/apps/studio/lib/sentry-client-options.ts@@ -0,0 +1,368 @@+// Shared Sentry client-side configuration for BOTH Studio builds:+//+// - Next (pages router): `instrumentation-client.ts` — a Next convention+// file, auto-loaded by Next only — calls `Sentry.init` with these options.+// - TanStack Start (Vite): `sentry.tanstack.ts` calls `Sentry.init`+// with these options from `getRouter()` (router.tsx). TanStack Start does+// not load Next's convention files, so without its own init every+// `Sentry.captureException` there would be a silent no-op.+//+// Keep every shared option in this builder so the two runtimes cannot drift.+//+// `@sentry/react` is what `@sentry/nextjs` wraps on the client (same 10.x+// version, same module instance under pnpm), so building the options against+// it works for both `Sentry.init`s.+import * as Sentry from '@sentry/react'+import { thirdPartyErrorFilterIntegration } from '@sentry/react'+import { hasConsented } from 'common'+import { IS_PLATFORM } from 'common/constants/environment'++import { MIRRORED_BREADCRUMBS } from '@/lib/breadcrumbs'+import { sanitizeArrayOfObjects, sanitizeUrlHashParams } from '@/lib/sanitize'++type Integration = Parameters<typeof Sentry.addIntegration>[0]++const DEFAULT_ERROR_SAMPLE_RATE = 1.0+const LOW_PRIORITY_ERROR_SAMPLE_RATE = 0.01+const CHUNK_LOAD_ERROR_PATTERNS = [+ /ChunkLoadError/i,+ /Loading chunk [\d]+ failed/i,+ /Loading CSS chunk [\d]+ failed/i,+]++// This is a workaround to ignore hCaptcha related errors.+function isHCaptchaRelatedError(event: Sentry.Event): boolean {+ const errors = event.exception?.values ?? []+ for (const error of errors) {+ if (+ error.value?.includes('is not a function') &&+ error.stacktrace?.frames?.some((f) => f.filename === 'api.js')+ ) {+ return true+ }+ }+ return false+}++// Filter browser wallet extension errors (e.g., Gate.io wallet)+// These errors come from injected wallet scripts and are not actionable+// Examples: SUPABASE-APP-AFC, SUPABASE-APP-92A+export function isBrowserWalletExtensionError(event: Sentry.Event): boolean {+ const frames = event.exception?.values?.flatMap((e) => e.stacktrace?.frames || []) || []+ return frames.some((frame) => {+ const filename = frame.filename || frame.abs_path || ''+ return filename.includes('gt-window-provider') || filename.includes('wallet-provider')+ })+}++// Filter user-aborted operations (intentional cancellations)+// These are expected when users cancel requests or navigate away+// Examples: SUPABASE-APP-BG6, SUPABASE-APP-BG7+export function isUserAbortedOperation(error: unknown, event: Sentry.Event): boolean {+ const errorMessage = error instanceof Error ? error.message : ''+ const eventMessage = event.message || ''+ const message = errorMessage || eventMessage++ return (+ message.includes('operation was aborted') ||+ message.includes('signal is aborted') ||+ message.includes('manually canceled') ||+ message.includes('AbortError')+ )+}++// Filter cancellation promise rejections (e.g., from query cancellation)+// These occur when operations are intentionally cancelled by the user+// Example: SUPABASE-APP-353 (~466k events)+export function isCancellationRejection(event: Sentry.Event): boolean {+ const serialized = event.extra?.__serialized__ as Record<string, unknown> | undefined+ return serialized?.type === 'cancelation'+}++// Filter challenge/captcha expired errors (user timeout)+// These happen when users don't complete captcha in time - expected behavior+// Example: SUPABASE-APP-ACC+export function isChallengeExpiredError(error: unknown, event: Sentry.Event): boolean {+ const errorMessage = error instanceof Error ? error.message : ''+ const eventMessage = event.message || ''+ const message = errorMessage || eventMessage++ return message.includes('challenge-expired')+}++function isChunkLoadError(error: unknown, event: Sentry.Event): boolean {+ const errorMessage = error instanceof Error ? error.message : ''+ const eventMessage = event.message || ''+ const exceptionMessages = event.exception?.values?.map((ex) => ex.value ?? '') ?? []+ const combinedMessages = [errorMessage, eventMessage, ...exceptionMessages].filter(Boolean)++ return CHUNK_LOAD_ERROR_PATTERNS.some((pattern) =>+ combinedMessages.some((message) => pattern.test(message))+ )+}++// Tag errors whose stack trace only contains third-party frames (browser extensions,+// injected scripts, etc.). This uses build-time code annotation via the applicationKey+// in next.config.ts to reliably distinguish our code from third-party code.+// We use 'apply-tag' instead of 'drop' so that beforeSend can exempt error boundary+// crashes — these may originate in third-party code but are caused by first-party bugs.+function buildThirdPartyErrorFilterIntegration(): Integration {+ return thirdPartyErrorFilterIntegration({+ filterKeys: ['supabase-studio'],+ behaviour: 'apply-tag-if-exclusively-contains-third-party-frames',+ })+}++export interface SentryClientOptionsParams {+ /**+ * Whether to include `thirdPartyErrorFilterIntegration`.+ *+ * Only enable this on builds whose bundler annotates stack frames with the+ * `supabase-studio` applicationKey (the Next build does, via+ * `withSentryConfig` in next.config.ts). On a build WITHOUT the annotation+ * no frame carries first-party metadata, so the integration tags EVERY+ * event `third_party_code: true` and `beforeSend` would then drop all+ * non-error-boundary events.+ */+ includeThirdPartyErrorFilter: boolean+ /** Build-specific integrations (e.g. TanStack Router browser tracing). */+ extraIntegrations?: Integration[]+ /**+ * Release identifier for the client.+ *+ * The SDK SILENTLY DROPS session envelopes when the client has no release+ * (`Client.sendSession` early-returns), so a build without a release sends+ * no Release Health traffic at all — errors and traces still flow.+ *+ * The Next build must NOT pass this: `withSentryConfig` injects the release+ * (`SENTRY_RELEASE` ?? the Vercel commit SHA) into the bundle at build time,+ * and an explicit `release` key — even `undefined` — would override it.+ * The TanStack/Vite build runs no Sentry bundler plugin, so it passes the+ * commit SHA here instead (see sentry.tanstack.ts).+ */+ release?: string+}++export function buildSentryClientOptions({+ includeThirdPartyErrorFilter,+ extraIntegrations = [],+ release,+}: SentryClientOptionsParams): Sentry.BrowserOptions {+ return {+ dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,+ ...(process.env.NEXT_PUBLIC_SENTRY_ENVIRONMENT && {+ environment: process.env.NEXT_PUBLIC_SENTRY_ENVIRONMENT,+ }),+ // Conditional spread: see the `release` doc comment above — the key must+ // be ABSENT (not `undefined`) so the Next build's injected release wins.+ ...(release && { release }),+ // Setting this option to true will print useful information to the console while you're setting up Sentry.+ debug: false,++ // Enable performance monitoring+ tracesSampleRate: 0.02,++ // Function form so Sentry's default integrations (browserSession,+ // globalHandlers, breadcrumbs, dedupe, …) are explicitly preserved — this+ // is the documented way to extend the defaults, and it can never be+ // misread as replacing them.+ integrations: (defaultIntegrations) => [+ ...defaultIntegrations,+ ...(includeThirdPartyErrorFilter ? [buildThirdPartyErrorFilterIntegration()] : []),+ ...extraIntegrations,+ ],++ // Only capture errors originating from our own code.+ // This is a whitelist on the source URL in stack frames — it drops errors from+ // browser extensions, injected scripts, third-party widgets, etc. (FE-2094)+ allowUrls: [+ /https?:\/\/(.*\.)?supabase\.(com|co|green|io)/,+ /app:\/\//, // Next.js rewrites source URLs to app:// with source maps+ ],+ beforeBreadcrumb(breadcrumb, _hint) {+ const cleanedBreadcrumb = { ...breadcrumb }++ if (cleanedBreadcrumb.category === 'navigation') {+ if (typeof cleanedBreadcrumb.data?.from === 'string') {+ cleanedBreadcrumb.data.from = sanitizeUrlHashParams(cleanedBreadcrumb.data.from)+ }+ if (typeof cleanedBreadcrumb.data?.to === 'string') {+ cleanedBreadcrumb.data.to = sanitizeUrlHashParams(cleanedBreadcrumb.data.to)+ }+ }++ MIRRORED_BREADCRUMBS.pushBack(cleanedBreadcrumb)+ return cleanedBreadcrumb+ },+ beforeSend(event, hint) {+ const consent = hasConsented()++ if (!consent) {+ return null+ }++ if (!IS_PLATFORM) {+ return null+ }++ const isErrorBoundaryCrash =+ event.tags?.globalErrorBoundary === true || event.tags?.globalErrorBoundary === 'true'+ const isThirdPartyOnly =+ event.tags?.third_party_code === true || event.tags?.third_party_code === 'true'++ // Drop third-party-only errors UNLESS they crashed the page via the global error boundary.+ // This preserves noise reduction for browser extensions and injected scripts,+ // while ensuring page-crashing errors from third-party libs (caused by first-party bugs)+ // are always reported.+ if (isThirdPartyOnly && !isErrorBoundaryCrash) {+ return null+ }++ // Downsample only known high-noise classes; keep all other errors at full rate.+ const isInvalidUrlEvent = (hint.originalException as any)?.message?.includes(+ `Failed to construct 'URL': Invalid URL`+ )+ const isSessionTimeoutEvent = (hint.originalException as any)?.message?.includes(+ 'Session error detected'+ )+ const isChunkLoadFailure = isChunkLoadError(hint.originalException, event)++ const codeSampleRate =+ isInvalidUrlEvent || isSessionTimeoutEvent || isChunkLoadFailure+ ? LOW_PRIORITY_ERROR_SAMPLE_RATE+ : DEFAULT_ERROR_SAMPLE_RATE++ if (Math.random() > codeSampleRate) {+ return null+ }++ event.tags = {+ ...event.tags,+ codeSampleRate: codeSampleRate.toString(),+ }++ if (isHCaptchaRelatedError(event)) {+ return null+ }++ // Drop events where every exception has no stack trace — these are not debuggable.+ // Exempt error boundary crashes: even without stack frames, a page crash is always worth reporting.+ const exceptions = event.exception?.values ?? []+ if (+ !isErrorBoundaryCrash &&+ exceptions.length > 0 &&+ exceptions.every((ex) => !ex.stacktrace?.frames?.length)+ ) {+ return null+ }++ // Filter out errors like 'e._5BLbSXV[t] is not a function' or anything matching '[t] is not a function'+ if (+ hint.originalException instanceof Error &&+ hint.originalException.message.includes('[t] is not a function')+ ) {+ return null+ }++ if (isBrowserWalletExtensionError(event)) {+ return null+ }+ if (isUserAbortedOperation(hint.originalException, event)) {+ return null+ }+ if (isCancellationRejection(event)) {+ return null+ }+ if (isChallengeExpiredError(hint.originalException, event)) {+ return null+ }++ if (event.breadcrumbs) {+ event.breadcrumbs = sanitizeArrayOfObjects(event.breadcrumbs) as Sentry.Breadcrumb[]+ }+ return event+ },+ ignoreErrors: [+ // === Monaco Editor ===+ 'ResizeObserver',+ 's.getModifierState is not a function',+ /^Uncaught NetworkError: Failed to execute 'importScripts' on 'WorkerGlobalScope'/,++ // === Browser extension errors ===+ // Gate.io wallet+ 'shouldSetTallyForCurrentProvider is not a function',+ // SAP browser extensions (SAP GUI, SAP Companion)+ 'sap is not defined',+ // Non-Error objects thrown as exceptions (e.g., Event objects)+ '[object Event]',++ // === Third-party SDK errors ===+ // stripe-js: https://github.com/stripe/stripe-js/issues/26+ 'Failed to load Stripe.js',+ // hCaptcha+ "undefined is not an object (evaluating 'n.chat.setReady')",+ "undefined is not an object (evaluating 'i.chat.setReady')",++ // === Next.js internals ===+ // Ref: https://github.com/supabase/supabase/pull/9729+ /The provided `href` \(\/org\/\[slug\]\/.*\) value is missing query values/,+ // Next.js throws these during navigation, not actual errors+ 'NEXT_NOT_FOUND',+ 'NEXT_REDIRECT',++ // === User input errors (not bugs) ===+ // sql-formatter lexer on invalid SQL input+ /^Parse error: Unexpected ".+" at line \d+ column \d+$/,++ // === Network / infrastructure (not actionable on FE) ===+ /504 Gateway Time-out/,+ 'Network request failed',+ 'Failed to fetch',+ 'Load failed',+ 'AbortError',+ 'TypeError: cancelled',+ 'TypeError: Cancelled',++ // === Browser extensions & Google Translate DOM manipulation ===+ 'Node.insertBefore: Child to insert before is not a child of this node',+ 'Node.removeChild: The node to be removed is not a child of this node',+ "NotFoundError: Failed to execute 'removeChild' on 'Node'",+ "NotFoundError: Failed to execute 'insertBefore' on 'Node'",+ 'NotFoundError: The object can not be found here.',+ "Cannot read properties of null (reading 'parentNode')",+ "Cannot read properties of null (reading 'removeChild')",+ "TypeError: can't access dead object",+ /^NS_ERROR_/,++ // === Non-Error throws (extensions, third-party libs throwing strings/objects) ===+ 'Non-Error exception captured',+ 'Non-Error promise rejection captured',+ /^Object captured as exception with keys:/,++ // === Cross-origin script errors (no useful info) ===+ 'Script error.',+ 'Script error',++ // === React hydration mismatches caused by extensions modifying DOM ===+ // Note: we only suppress the generic browser messages, NOT "Hydration failed because..."+ // which can indicate real SSR/client mismatches in our own code.+ /text content does not match/i,+ /There was an error while hydrating/i,++ // === Web crawler / bot errors ===+ 'instantSearchSDKJSBridgeClearHighlight',++ // === Third-party library race conditions ===+ // cmdk: useSyncExternalStore subscribe called before store context is available+ "Cannot read properties of undefined (reading 'subscribe')",+ "undefined is not an object (evaluating 't.subscribe')",++ // === Misc known noise ===+ 'r.default.setDefaultLevel is not a function',+ // Clipboard permission denied+ 'The request is not allowed by the user agent or the platform in the current context, possibly because the user denied permission.',+ // Facebook pixel+ 'fb_xd_fragment',+ ],+ }+}diff --git a/apps/studio/router.tsx b/apps/studio/router.tsxindex 35a24884b76..81f101d4c91 100644--- a/apps/studio/router.tsx+++ b/apps/studio/router.tsx@@ -3,6 +3,7 @@ import { createRouter } from '@tanstack/react-router'import { setupRouterSsrQueryIntegration } from '@tanstack/react-router-ssr-query'import { routeTree } from './routeTree.gen'+import { initSentryTanStackClient } from './sentry.tanstack'import { getQueryClient } from '@/data/query-client'import { BASE_PATH, IS_PLATFORM } from '@/lib/constants'import { parseSearch, stringifySearch } from '@/lib/router-search-params'@@ -87,6 +88,12 @@ export function getRouter() {basepath: process.env.NEXT_PUBLIC_BASE_PATH || undefined,})+ // Sentry: nothing loads Next's convention files (instrumentation-client.ts)+ // under TanStack Start, so init happens here — the earliest point with+ // access to the router instance, which the tracing integration needs.+ // No-op on the server and when no DSN is configured (see module).+ initSentryTanStackClient(router)+// @tanstack/[email protected] pulls in @tanstack/[email protected]// as a peer, but our app pins react-query to 5.83. The QueryClient class is// structurally identical between the two, but TS treats them as nominallydiff --git a/apps/studio/sentry.tanstack.test.ts b/apps/studio/sentry.tanstack.test.tsnew file mode 100644index 00000000000..2adb968ef6a--- /dev/null+++ b/apps/studio/sentry.tanstack.test.ts@@ -0,0 +1,136 @@+import type { AnyRouter } from '@tanstack/react-router'+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'++const sentryMocks = vi.hoisted(() => ({+ init: vi.fn(),+ tanstackRouterBrowserTracingIntegration: vi.fn(() => ({+ name: 'TanStackRouterBrowserTracing',+ })),+ // Imported at module scope by lib/sentry-client-options.ts, so the mock+ // must provide it even though the TanStack init never enables it.+ thirdPartyErrorFilterIntegration: vi.fn(() => ({ name: 'ThirdPartyErrorsFilter' })),+}))++vi.mock('@sentry/react', () => sentryMocks)++// The integration only needs a router reference to hook navigation events, and+// it is mocked here — a stub stands in for the real router at this boundary.+const fakeRouter = { subscribe: vi.fn() } as unknown as AnyRouter++// sentry.tanstack.ts keeps a module-level `initialized` flag, so each test+// imports a fresh copy of the module.+async function loadInitializer() {+ vi.resetModules()+ const { initSentryTanStackClient } = await import('./sentry.tanstack')+ return initSentryTanStackClient+}++describe('initSentryTanStackClient', () => {+ beforeEach(() => {+ vi.clearAllMocks()+ })++ afterEach(() => {+ vi.unstubAllGlobals()+ vi.unstubAllEnvs()+ })++ it('does not initialize Sentry during SSR/prerender (no window)', async () => {+ const initSentryTanStackClient = await loadInitializer()+ vi.stubGlobal('window', undefined)++ initSentryTanStackClient(fakeRouter)++ expect(sentryMocks.init).not.toHaveBeenCalled()+ })++ it('initializes Sentry in the browser with the shared client options', async () => {+ vi.stubEnv('NEXT_PUBLIC_SENTRY_DSN', 'https://[email protected]/1')+ const initSentryTanStackClient = await loadInitializer()++ initSentryTanStackClient(fakeRouter)++ expect(sentryMocks.init).toHaveBeenCalledTimes(1)+ expect(sentryMocks.init).toHaveBeenCalledWith(+ expect.objectContaining({+ dsn: 'https://[email protected]/1',+ tracesSampleRate: 0.02,+ })+ )+ })++ it('passes an undefined dsn when NEXT_PUBLIC_SENTRY_DSN is unset (disabled-client no-op)', async () => {+ vi.stubEnv('NEXT_PUBLIC_SENTRY_DSN', undefined)+ const initSentryTanStackClient = await loadInitializer()++ initSentryTanStackClient(fakeRouter)++ // `Sentry.init` without a dsn creates a disabled client, so calling init+ // unconditionally is safe for local/self-hosted builds.+ expect(sentryMocks.init).toHaveBeenCalledTimes(1)+ expect(sentryMocks.init).toHaveBeenCalledWith(expect.objectContaining({ dsn: undefined }))+ })++ it('only initializes once across repeated calls', async () => {+ const initSentryTanStackClient = await loadInitializer()++ initSentryTanStackClient(fakeRouter)+ initSentryTanStackClient(fakeRouter)++ expect(sentryMocks.init).toHaveBeenCalledTimes(1)+ })++ it('still initializes in the browser after an earlier SSR call', async () => {+ const initSentryTanStackClient = await loadInitializer()++ // An SSR call must not trip the idempotency guard for the browser call.+ vi.stubGlobal('window', undefined)+ initSentryTanStackClient(fakeRouter)+ expect(sentryMocks.init).not.toHaveBeenCalled()++ vi.unstubAllGlobals()+ initSentryTanStackClient(fakeRouter)+ expect(sentryMocks.init).toHaveBeenCalledTimes(1)+ })++ it('wires the TanStack Router browser tracing integration for the given router', async () => {+ const initSentryTanStackClient = await loadInitializer()++ initSentryTanStackClient(fakeRouter)++ expect(sentryMocks.tanstackRouterBrowserTracingIntegration).toHaveBeenCalledWith(fakeRouter)++ const [options] = sentryMocks.init.mock.calls[0]+ // `integrations` is the function form: Sentry.init calls it with the+ // default integrations (browserSession, globalHandlers, …) and installs+ // whatever it returns, so the defaults must survive the merge.+ expect(options.integrations).toBeTypeOf('function')+ const defaultIntegrations = [{ name: 'BrowserSession' }, { name: 'GlobalHandlers' }]+ const integrations = options.integrations(defaultIntegrations)++ // Defaults passed in by Sentry.init survive the merge.+ expect(integrations).toContainEqual({ name: 'BrowserSession' })+ expect(integrations).toContainEqual({ name: 'GlobalHandlers' })+ expect(integrations).toContainEqual({ name: 'TanStackRouterBrowserTracing' })+ // The Vite build runs no Sentry bundler plugin, so frames carry no+ // applicationKey metadata — the third-party filter must stay off or every+ // event would be tagged third_party_code=true and dropped by beforeSend.+ expect(sentryMocks.thirdPartyErrorFilterIntegration).not.toHaveBeenCalled()+ expect(integrations).not.toContainEqual({ name: 'ThirdPartyErrorsFilter' })+ })++ it('passes the Vercel commit SHA as the release so session envelopes are sent', async () => {+ // The SDK silently drops session envelopes when the client has no release+ // (`Client.sendSession` early-returns) — without this, Release Health+ // sends no /envelope traffic at all on the TanStack build. The Next build+ // instead gets its release injected at build time by withSentryConfig.+ vi.stubEnv('NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA', 'abc123commit')+ const initSentryTanStackClient = await loadInitializer()++ initSentryTanStackClient(fakeRouter)++ expect(sentryMocks.init).toHaveBeenCalledWith(+ expect.objectContaining({ release: 'abc123commit' })+ )+ })+})diff --git a/apps/studio/sentry.tanstack.ts b/apps/studio/sentry.tanstack.tsnew file mode 100644index 00000000000..075198c3904--- /dev/null+++ b/apps/studio/sentry.tanstack.ts@@ -0,0 +1,66 @@+// Sentry client init for the TanStack Start (Vite) build.+//+// NOTE: deliberately not named `sentry.client.tanstack.ts` — TanStack Start's+// import-protection denies `**/*.client.*` modules in the server bundle, and+// this module is imported from router.tsx (shared between client and server).+// It is isomorphic by design: the `typeof window` guard below makes it a+// no-op on the server.+//+// The Next build initializes Sentry via instrumentation-client.ts — a Next+// convention file that nothing loads under TanStack Start. Without this init+// every `Sentry.captureException` in the TanStack runtime (including the+// globalErrorBoundary / routerErrorComponent captures in routes/__root.tsx)+// would be a silent no-op.+//+// Called from `getRouter()` (router.tsx) — the earliest point in the TanStack+// client bootstrap with access to the router instance, which+// `tanstackRouterBrowserTracingIntegration` needs at init time so the+// pageload span is captured, not just later navigations.+//+// Imports `@sentry/react` directly (not `@sentry/nextjs`): this module never+// runs on the Next build, and the real `@sentry/nextjs` doesn't export the+// TanStack Router integration. Under Vite both ids resolve to the same+// `@sentry/react` instance anyway (vite.config.ts aliases `@sentry/nextjs`+// to compat/sentry-nextjs.ts), so app code capturing via `@sentry/nextjs`+// reports through the client initialized here.+import * as Sentry from '@sentry/react'+import type { AnyRouter } from '@tanstack/react-router'++import { buildSentryClientOptions } from '@/lib/sentry-client-options'++let isInitialized = false++export function initSentryTanStackClient(router: AnyRouter) {+ // Client-only: getRouter() also runs during SSR/prerender, and the TanStack+ // build has no server-side Sentry story yet (the Next build's+ // sentry.server.config.ts equivalent would live in a custom server entry).+ if (typeof window === 'undefined') return+ // getRouter() is called once per pageload today; keep the guard so a future+ // second call can't double-init the client.+ if (isInitialized) return+ isInitialized = true++ // No-ops cleanly when NEXT_PUBLIC_SENTRY_DSN is unset (local/self-hosted):+ // `init` without a dsn creates a disabled client, and beforeSend drops+ // everything when !IS_PLATFORM regardless.+ Sentry.init(+ buildSentryClientOptions({+ // The Vite build doesn't run a Sentry bundler plugin, so stack frames+ // carry no `supabase-studio` applicationKey metadata. Without the+ // metadata the integration would tag EVERY event third_party_code=true+ // and beforeSend would drop them all. Leave it off until the Vite build+ // annotates frames (@sentry/vite-plugin moduleMetadata).+ includeThirdPartyErrorFilter: false,+ extraIntegrations: [Sentry.tanstackRouterBrowserTracingIntegration(router)],+ // Without a release the SDK silently drops session envelopes+ // (`Client.sendSession` early-returns), so Release Health sends nothing+ // on this build. The Next build gets its release injected at build time+ // by withSentryConfig, which resolves to the Vercel commit SHA; inline+ // the same SHA here (vite.config.ts re-exposes VERCEL_GIT_COMMIT_SHA+ // under the NEXT_PUBLIC_ name) so both builds report the same release.+ // Unset outside Vercel (local/self-hosted), where sessions don't matter —+ // so session envelopes only fire on deploys, not on a local dev build.+ release: process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA,+ })+ )+}diff --git a/apps/studio/vite.config.ts b/apps/studio/vite.config.tsindex 23979bed19b..60849d6f3d0 100644--- a/apps/studio/vite.config.ts+++ b/apps/studio/vite.config.ts@@ -372,6 +372,11 @@ export default defineConfig(({ command, mode }) => {// router.tsx). Both are build-time system env vars on Vercel.'VERCEL_DEPLOYMENT_ID','VERCEL_SKEW_PROTECTION_ENABLED',+ // Sentry release (sentry.tanstack.ts): the SDK silently drops session+ // envelopes when the client has no release, so Release Health would send+ // nothing. The commit SHA is also what withSentryConfig resolves the Next+ // build's release to, keeping release names aligned across both builds.+ 'VERCEL_GIT_COMMIT_SHA',] as constfor (const key of vercelPublicVars) {const value = env[key]@@ -380,6 +385,20 @@ export default defineConfig(({ command, mode }) => {}}+ // Sentry init (lib/sentry-client-options.ts, reached via router.tsx) reads+ // these at runtime in the browser. When a var is unset it gets no define+ // entry above, which would leave a literal `process.env.*` in the built+ // bundle — and an undeclared `process` throws in the browser. Inline+ // `undefined` as the fallback, mirroring how Next inlines unset+ // NEXT_PUBLIC_* vars.+ for (const key of [+ 'NEXT_PUBLIC_SENTRY_DSN',+ 'NEXT_PUBLIC_SENTRY_ENVIRONMENT',+ 'NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA',+ ]) {+ publicEnvDefines[`process.env.${key}`] ??= 'undefined'+ }+// Mirror Next's `basePath` via NEXT_PUBLIC_BASE_PATH. Unlike Next, TanStack// Start has no single knob — the prefix has to be declared in three places// (see BASE_PATH_REDIRECT_GUIDE.md):