Skip all RPC calls in PostgREST instrumentation to prevent duplicate spans

Author: onurtemizkan

dev-packages/browser-integration-tests/suites/integrations/supabase/generic-rpc/init.js

@@ -0,0 +1,23 @@
+import * as Sentry from '@sentry/browser';
+import { createClient } from '@supabase/supabase-js';
+
+window.Sentry = Sentry;
+
+const supabaseClient = createClient('https://test.supabase.co', 'test-key');
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration(), Sentry.supabaseIntegration({ supabaseClient })],
+  tracesSampleRate: 1.0,
+});
+
+// Simulate generic RPC call
+async function callGenericRpc() {
+  try {
+    await supabaseClient.rpc('my_custom_function', { param1: 'value1' });
+  } catch (error) {
+    Sentry.captureException(error);
+  }
+}
+
+callGenericRpc();

dev-packages/browser-integration-tests/suites/integrations/supabase/generic-rpc/test.ts

@@ -0,0 +1,59 @@
+import type { Page } from '@playwright/test';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+
+async function mockSupabaseRoute(page: Page) {
+  await page.route('**/rpc/my_custom_function', route => {
+    return route.fulfill({
+      status: 200,
+      body: JSON.stringify({ result: 'success' }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+  });
+}
+
+const bundle = process.env.PW_BUNDLE || '';
+// We only want to run this in non-CDN bundle mode
+if (bundle.startsWith('bundle')) {
+  sentryTest.skip();
+}
+
+sentryTest(
+  'should capture exactly one db span for generic RPC calls (no double instrumentation)',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      return;
+    }
+
+    await mockSupabaseRoute(page);
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const event = await getFirstSentryEnvelopeRequest<Event>(page, url);
+    const dbSpans = event.spans?.filter(({ op }) => op === 'db');
+
+    // Should have exactly one db span (not doubled by PostgREST instrumentation)
+    expect(dbSpans).toHaveLength(1);
+
+    expect(dbSpans![0]).toMatchObject({
+      description: 'rpc(my_custom_function)',
+      parent_span_id: event.contexts?.trace?.span_id,
+      span_id: expect.any(String),
+      start_timestamp: expect.any(Number),
+      timestamp: expect.any(Number),
+      trace_id: event.contexts?.trace?.trace_id,
+      data: expect.objectContaining({
+        'sentry.op': 'db',
+        'sentry.origin': 'auto.db.supabase',
+        'db.system': 'postgresql',
+        'db.operation': 'insert',
+        'db.table': 'my_custom_function',
+        'db.params': { param1: 'value1' },
+      }),
+    });
+  },
+);

packages/core/src/integrations/supabase/postgrest.ts

@@ -5,7 +5,7 @@ import { setHttpStatus, startInactiveSpan, withActiveSpan } from '../../tracing'
 import type { SpanAttributes } from '../../types-hoist/span';
 import { debug } from '../../utils/debug-logger';
 import { isPlainObject } from '../../utils/is';
-import { DB_OPERATIONS_TO_INSTRUMENT, QUEUE_RPC_OPERATIONS } from './constants';
+import { DB_OPERATIONS_TO_INSTRUMENT } from './constants';
 import { captureSupabaseError } from './errors';
 import type {
   PostgRESTFilterBuilder,
@@ -17,13 +17,7 @@ import type {
   SupabaseError,
   SupabaseResponse,
 } from './types';
-import {
-  _isInstrumented,
-  _markAsInstrumented,
-  _normalizeRpcFunctionName,
-  extractOperation,
-  translateFiltersIntoMethods,
-} from './utils';
+import { _isInstrumented, _markAsInstrumented, extractOperation, translateFiltersIntoMethods } from './utils';
 
 /**
  * Instruments PostgREST filter builder to trace database operations.
@@ -67,11 +61,9 @@ function _createInstrumentedPostgRESTThen(
 
       const pathParts = typedThis.url.pathname.split('/');
       const rpcIndex = pathParts.indexOf('rpc');
-      const rpcFunctionName = rpcIndex !== -1 && pathParts.length > rpcIndex + 1 ? pathParts[rpcIndex + 1] : undefined;
-
-      // Normalize RPC function name to handle schema-qualified names (e.g., 'pgmq.send' → 'send')
-      if (rpcFunctionName && QUEUE_RPC_OPERATIONS.has(_normalizeRpcFunctionName(rpcFunctionName))) {
-        // Queue RPC calls are instrumented in the dedicated queue instrumentation.
+      // Skip all RPC calls - they are fully instrumented in rpc.ts
+      // (both queue operations and generic RPC functions)
+      if (rpcIndex !== -1) {
         return Reflect.apply(target, thisArg, argumentsList);
       }