Add auth error capturing

Author: onurtemizkan

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

@@ -3,32 +3,22 @@ import * as Sentry from '@sentry/browser';
 import { createClient } from '@supabase/supabase-js';
 window.Sentry = Sentry;
 
-const supabase = createClient(
-  'https://test.supabase.co',
-  'test-key'
-);
+const supabase = createClient('https://test.supabase.co', 'test-key');
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [
-    Sentry.browserTracingIntegration(),
-    Sentry.supabaseIntegration(supabase)
-  ],
+  integrations: [Sentry.browserTracingIntegration(), Sentry.supabaseIntegration(supabase)],
   tracesSampleRate: 1.0,
 });
 
 // Simulate authentication operations
 async function performAuthenticationOperations() {
-  try {
-    await supabase.auth.signInWithPassword({
-      email: 'test@example.com',
-      password: 'test-password',
-    });
+  await supabase.auth.signInWithPassword({
+    email: 'test@example.com',
+    password: 'test-password',
+  });
 
-    await supabase.auth.signOut();
-  } catch (error) {
-    Sentry.captureException(error);
-  }
+  await supabase.auth.signOut();
 }
 
 performAuthenticationOperations();

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

@@ -9,7 +9,7 @@ import {
   shouldSkipTracingTest,
 } from '../../../../utils/helpers';
 
-async function mockSupabaseAuthRoutes(page: Page) {
+async function mockSupabaseAuthRoutesSuccess(page: Page) {
   await page.route('**/auth/v1/token?grant_type=password**', route => {
     return route.fulfill({
       status: 200,
@@ -38,12 +38,40 @@ async function mockSupabaseAuthRoutes(page: Page) {
   });
 }
 
+async function mockSupabaseAuthRoutesFailure(page: Page) {
+  await page.route('**/auth/v1/token?grant_type=password**', route => {
+    return route.fulfill({
+      status: 400,
+      body: JSON.stringify({
+        error_description: 'Invalid email or password',
+        error: 'invalid_grant',
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+  });
+
+  await page.route('**/auth/v1/logout**', route => {
+    return route.fulfill({
+      status: 400,
+      body: JSON.stringify({
+        error_description: 'Invalid refresh token',
+        error: 'invalid_grant',
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+  });
+}
+
 sentryTest('should capture Supabase authentication spans', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
     return;
   }
 
-  await mockSupabaseAuthRoutes(page);
+  await mockSupabaseAuthRoutesSuccess(page);
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
@@ -79,3 +107,34 @@ sentryTest('should capture Supabase authentication spans', async ({ getLocalTest
     }),
   });
 });
+
+sentryTest('should capture Supabase authentication errors', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    return;
+  }
+
+  await mockSupabaseAuthRoutesFailure(page);
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const [errorEvent, transactionEvent] = await getMultipleSentryEnvelopeRequests<Event>(page, 2, { url });
+
+  const supabaseSpans = transactionEvent.spans?.filter(({ op }) => op?.startsWith('db.supabase.auth'));
+
+  expect(errorEvent.exception?.values?.[0].value).toBe('Invalid email or password');
+
+  expect(supabaseSpans).toHaveLength(2);
+  expect(supabaseSpans![0]).toMatchObject({
+    description: 'signInWithPassword',
+    parent_span_id: transactionEvent.contexts?.trace?.span_id,
+    span_id: expect.any(String),
+    start_timestamp: expect.any(Number),
+    timestamp: expect.any(Number),
+    trace_id: transactionEvent.contexts?.trace?.trace_id,
+    status: 'unknown_error',
+    data: expect.objectContaining({
+      'sentry.op': 'db.supabase.auth.signInWithPassword',
+      'sentry.origin': 'auto.db.supabase',
+    }),
+  });
+});

packages/core/src/integrations/supabase.ts

@@ -196,27 +196,44 @@ export function translateFiltersIntoMethods(key: string, query: string): string
 function instrumentAuthOperation(operation: AuthOperationFn, isAdmin = false): AuthOperationFn {
   return new Proxy(operation, {
     apply(target, thisArg, argumentsList) {
-      startSpan(
+      return startSpan(
         {
           name: operation.name,
           attributes: {
             [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.db.supabase',
             [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `db.supabase.auth.${isAdmin ? 'admin.' : ''}${operation.name}`,
           },
         },
-        span => {
-          return Reflect.apply(target, thisArg, argumentsList).then((res: unknown) => {
-            debugger;
-            if (res && typeof res === 'object' && 'error' in res && res.error) {
+        async span => {
+          return Reflect.apply(target, thisArg, argumentsList)
+            .then((res: unknown) => {
+              if (res && typeof res === 'object' && 'error' in res && res.error) {
+                span.setStatus({ code: SPAN_STATUS_ERROR });
+
+                captureException(res.error, {
+                  mechanism: {
+                    handled: false,
+                  },
+                });
+              } else {
+                span.setStatus({ code: SPAN_STATUS_OK });
+              }
+
+              span.end();
+              return res;
+            })
+            .catch((err: unknown) => {
               span.setStatus({ code: SPAN_STATUS_ERROR });
-            } else {
-              span.setStatus({ code: SPAN_STATUS_OK });
-            }
-
-            span.end();
-            debugger;
-            return res;
-          });
+              span.end();
+
+              captureException(err, {
+                mechanism: {
+                  handled: false,
+                },
+              });
+
+              throw err;
+            });
         },
       );
     },
@@ -460,7 +477,7 @@ function instrumentPostgrestQueryBuilder(PostgrestQueryBuilder: new () => Postgr
 
 const instrumentSupabase = (supabaseClientInstance: unknown): void => {
   if (!supabaseClientInstance) {
-    throw new Error('Supabase client instance is not defined.');
+    throw new Error('Supabase client instance is not available.');
   }
   const SupabaseClientConstructor =
     supabaseClientInstance.constructor === Function ? supabaseClientInstance : supabaseClientInstance.constructor;