@jmruthers/pace-core 0.5.135 → 0.5.137

package/src/services/AuthService.ts

@@ -12,6 +12,7 @@ import { type SupabaseClient, type User, type Session, AuthError } from '@supaba
 import type { SessionRestorationState } from '../types/auth';
 import { BaseService } from './base/BaseService';
 import { IAuthService, AuthResult } from './interfaces/IAuthService';
+import { logger } from '../utils/core/logger';
 
 export class AuthService extends BaseService implements IAuthService {
   private user: User | null = null;
@@ -327,11 +328,11 @@ export class AuthService extends BaseService implements IAuthService {
     };
     this.authLoading = true;
     this.restorationStartTime = Date.now();
-    console.debug('[AuthService] Starting session restoration at', this.restorationStartTime);
+    logger.debug('AuthService', 'Starting session restoration at', this.restorationStartTime);
     this.notify();
 
     this.restorationTimeoutId = setTimeout(() => {
-      console.warn('[AuthService] Session restoration timed out after', this.restorationTimeoutMs, 'ms');
+      logger.warn('AuthService', 'Session restoration timed out after', this.restorationTimeoutMs, 'ms');
       const timeoutError = new Error(`Session restoration timed out after ${this.restorationTimeoutMs}ms`);
       timeoutError.name = 'SessionRestorationTimeoutError';
       this.finishSessionRestoration(timeoutError);
@@ -356,9 +357,9 @@ export class AuthService extends BaseService implements IAuthService {
     this.authLoading = false;
 
     if (error) {
-      console.warn('[AuthService] Session restoration finished with error:', error, 'duration(ms):', duration ?? 'unknown');
+      logger.warn('AuthService', 'Session restoration finished with error:', error, 'duration(ms):', duration ?? 'unknown');
     } else {
-      console.debug('[AuthService] Session restoration completed successfully in', duration ?? 'unknown', 'ms');
+      logger.debug('AuthService', 'Session restoration completed successfully in', duration ?? 'unknown', 'ms');
     }
 
     this.notify();
@@ -382,7 +383,7 @@ export class AuthService extends BaseService implements IAuthService {
       this.authStateSubscription = this.supabaseClient.auth.onAuthStateChange(
         (event, session) => {
           try {
-            console.debug('[AuthService] Auth state change event received:', event);
+            logger.debug('AuthService', 'Auth state change event received:', event);
             // Handle different auth events
             if (event === 'SIGNED_OUT') {
               this.session = null;
@@ -392,7 +393,7 @@ export class AuthService extends BaseService implements IAuthService {
               // Automatic session tracking (non-blocking)
               if (session?.user) {
                 this.trackSession('logout', session).catch(err => {
-                  console.warn('[AuthService] Failed to track logout session:', err);
+                  logger.warn('AuthService', 'Failed to track logout session:', err);
                 });
               }
             } else if (event === 'SIGNED_IN' || event === 'TOKEN_REFRESHED') {
@@ -408,7 +409,7 @@ export class AuthService extends BaseService implements IAuthService {
               // Only track on SIGNED_IN, not TOKEN_REFRESHED (to avoid duplicate login records)
               if (event === 'SIGNED_IN' && session?.user) {
                 this.trackSession('login', session).catch(err => {
-                  console.warn('[AuthService] Failed to track login session:', err);
+                  logger.warn('AuthService', 'Failed to track login session:', err);
                 });
               }
             } else if (event === 'INITIAL_SESSION') {
@@ -438,14 +439,14 @@ export class AuthService extends BaseService implements IAuthService {
             this.authLoading = false;
             this.notify();
           } catch (error) {
-            console.warn('[AuthService] Error in auth state change handler:', error);
+            logger.warn('AuthService', 'Error in auth state change handler:', error);
             this.authLoading = false;
             this.notify();
           }
         }
       );
     } catch (error) {
-      console.error('[AuthService] Failed to setup auth state listener:', error);
+      logger.error('AuthService', 'Failed to setup auth state listener:', error);
       throw error; // Re-throw to propagate to the provider
     }
   }
@@ -453,7 +454,7 @@ export class AuthService extends BaseService implements IAuthService {
   private async restoreSession(): Promise<void> {
     if (!this.supabaseClient) {
       const error = new Error('Supabase client not available during session restoration');
-      console.error('[AuthService] Unable to restore session:', error);
+      logger.error('AuthService', 'Unable to restore session:', error);
       this.finishSessionRestoration(error);
       return;
     }
@@ -461,7 +462,7 @@ export class AuthService extends BaseService implements IAuthService {
     this.startSessionRestoration();
 
     try {
-      console.debug('[AuthService] Fetching existing session from Supabase');
+      logger.debug('AuthService', 'Fetching existing session from Supabase');
       let currentSession: Session | null = null;
       let sessionError: AuthError | null = null;
 
@@ -471,14 +472,14 @@ export class AuthService extends BaseService implements IAuthService {
         sessionError = error ?? null;
       } catch (error) {
         // Handle cases where getSession might not exist (mocked/test clients)
-        console.debug('[AuthService] getSession unavailable, treating as no active session');
+        logger.debug('AuthService', 'getSession unavailable, treating as no active session');
         currentSession = null;
         sessionError = null;
       }
 
       if (sessionError) {
         // Record error but continue to attempt getUser to satisfy edge cases
-        console.debug('[AuthService] getSession returned error, attempting to fetch user anyway');
+        logger.debug('AuthService', 'getSession returned error, attempting to fetch user anyway');
         this.authError = sessionError;
         
         // Attempt getUser as fallback when getSession fails
@@ -497,7 +498,7 @@ export class AuthService extends BaseService implements IAuthService {
           }
         } catch (getUserError) {
           // If getUser also fails, we've already recorded the sessionError
-          console.debug('[AuthService] getUser also failed:', getUserError);
+          logger.debug('AuthService', 'getUser also failed:', getUserError);
         }
       }
 
@@ -509,7 +510,7 @@ export class AuthService extends BaseService implements IAuthService {
         // Only skip getUser if we didn't already attempt it due to a sessionError
         // Treat missing session as a normal cold-start state on public pages (e.g., login)
         // Do not call getUser() which can raise AuthSessionMissingError and surface a noisy banner
-        console.debug('[AuthService] No active session found; treating as normal unauthenticated state');
+        logger.debug('AuthService', 'No active session found; treating as normal unauthenticated state');
         this.session = null;
         this.user = null;
         this.authError = null;
@@ -521,7 +522,7 @@ export class AuthService extends BaseService implements IAuthService {
       const restorationError = error instanceof Error
         ? error
         : new Error('Unknown error during auth initialization');
-      console.error('[AuthService] Error during auth initialization:', restorationError);
+      logger.error('AuthService', 'Error during auth initialization:', restorationError);
       if (restorationError instanceof AuthError) {
         this.authError = restorationError;
       }
@@ -580,13 +581,13 @@ export class AuthService extends BaseService implements IAuthService {
       });
 
       if (error) {
-        console.warn(`[AuthService] Failed to track ${sessionType} session:`, error);
+        logger.warn('AuthService', `Failed to track ${sessionType} session:`, error);
       } else {
-        console.debug(`[AuthService] Successfully tracked ${sessionType} session`);
+        logger.debug('AuthService', `Successfully tracked ${sessionType} session`);
       }
     } catch (error) {
       // Log error but don't throw (non-blocking)
-      console.warn(`[AuthService] Error tracking ${sessionType} session:`, error);
+      logger.warn('AuthService', `Error tracking ${sessionType} session:`, error);
     }
   }
 
@@ -596,7 +597,7 @@ export class AuthService extends BaseService implements IAuthService {
     const handleError = (event: ErrorEvent) => {
       if (event.error?.message?.includes('AuthSessionMissingError') || 
           event.error?.message?.includes('Auth session missing')) {
-        console.warn('[AuthService] Suppressing AuthSessionMissingError during logout');
+        logger.warn('AuthService', 'Suppressing AuthSessionMissingError during logout');
         event.preventDefault();
         return false;
       }
@@ -605,7 +606,7 @@ export class AuthService extends BaseService implements IAuthService {
     const handleUnhandledRejection = (event: PromiseRejectionEvent) => {
       if (event.reason?.message?.includes('AuthSessionMissingError') ||
           event.reason?.message?.includes('Auth session missing')) {
-        console.warn('[AuthService] Suppressing unhandled AuthSessionMissingError');
+        logger.warn('AuthService', 'Suppressing unhandled AuthSessionMissingError');
         event.preventDefault();
         return false;
       }

package/src/services/EventService.ts

@@ -13,8 +13,8 @@ import { BaseService } from './base/BaseService';
 import { IEventService } from './interfaces/IEventService';
 import { Event } from '../types/unified';
 import { Organisation } from '../types/organisation';
-import { DebugLogger } from '../utils/debugLogger';
-import { secureStorage } from '../utils/secureStorage';
+import { logger } from '../utils/core/logger';
+import { secureStorage } from '../utils/security/secureStorage';
 
 export class EventService extends BaseService implements IEventService {
   private events: Event[] = [];
@@ -134,7 +134,7 @@ export class EventService extends BaseService implements IEventService {
       // SECURITY: Validate event belongs to current organisation
       try {
         if (this.selectedOrganisation && event.organisation_id !== this.selectedOrganisation.id) {
-          console.error('[EventService] Event organisation_id does not match selected organisation', {
+          logger.error('EventService', 'Event organisation_id does not match selected organisation', {
             eventOrganisationId: event.organisation_id,
             selectedOrganisationId: this.selectedOrganisation.id,
             eventName: event.event_name
@@ -142,14 +142,14 @@ export class EventService extends BaseService implements IEventService {
           return;
         }
       } catch (error) {
-        console.error('[EventService] Error during event validation:', error);
+        logger.error('EventService', 'Error during event validation:', error);
       }
 
       this.selectedEvent = event;
       this.setSelectedEventId?.(event.event_id);
       // Persist asynchronously (don't await to avoid blocking)
       this.persistEventSelection(event.event_id).catch(error => {
-        console.warn('[EventService] Failed to persist event selection:', error);
+        logger.warn('EventService', 'Failed to persist event selection:', error);
       });
       // Reset the user cleared flag when selecting an event
       this.userClearedEventRef = false;
@@ -158,7 +158,7 @@ export class EventService extends BaseService implements IEventService {
       this.setSelectedEventId?.(null);
       // Clear from secure storage (don't await to avoid blocking)
       this.clearEventSelection().catch(error => {
-        console.warn('[EventService] Failed to clear event selection:', error);
+        logger.warn('EventService', 'Failed to clear event selection:', error);
       });
       // Reset the auto-selection flag when clearing the event
       this.hasAutoSelectedRef = false;
@@ -205,7 +205,7 @@ export class EventService extends BaseService implements IEventService {
         }
       }
     } catch (error) {
-      console.warn('[EventService] Failed to load persisted event:', error);
+      logger.warn('EventService', 'Failed to load persisted event:', error);
     }
     return false;
   }
@@ -232,7 +232,7 @@ export class EventService extends BaseService implements IEventService {
       // Store with encryption using secureStorage
       await secureStorage.setItem(storageKey, eventId, { encrypt: true });
     } catch (error) {
-      console.warn('[EventService] Failed to persist event selection:', error);
+      logger.warn('EventService', 'Failed to persist event selection:', error);
     }
   }
 
@@ -248,7 +248,7 @@ export class EventService extends BaseService implements IEventService {
       this.selectedEvent = null;
       this.setSelectedEventId?.(null);
     } catch (error) {
-      console.warn('[EventService] Failed to clear event selection:', error);
+      logger.warn('EventService', 'Failed to clear event selection:', error);
     }
   }
 
@@ -262,7 +262,7 @@ export class EventService extends BaseService implements IEventService {
       const storageKey = this.getStorageKey(userId);
       await secureStorage.removeItem(storageKey);
     } catch (error) {
-      console.warn('[EventService] Failed to clear event selection for user:', error);
+      logger.warn('EventService', 'Failed to clear event selection for user:', error);
     }
   }
 
@@ -292,7 +292,7 @@ export class EventService extends BaseService implements IEventService {
         localStorage.removeItem('_sec_pace-core-selected-event');
       }
     } catch (error) {
-      console.warn('[EventService] Failed to clean up old storage keys:', error);
+      logger.warn('EventService', 'Failed to clean up old storage keys:', error);
     }
     
     // Load persisted event during initialization (don't skip)
@@ -399,7 +399,7 @@ export class EventService extends BaseService implements IEventService {
         }
       }
     } catch (err) {
-      console.error('[EventService] Error fetching events:', err);
+      logger.error('EventService', 'Error fetching events:', err);
       const _error = err instanceof Error ? err : new Error('Unknown error occurred');
       
       if (isMounted) {

package/src/services/InactivityService.ts

@@ -10,6 +10,7 @@
 
 import { BaseService } from './base/BaseService';
 import { IInactivityService } from './interfaces/IInactivityService';
+import { logger } from '../utils/core/logger';
 
 export class InactivityService extends BaseService implements IInactivityService {
   private _showInactivityWarning = false;
@@ -169,7 +170,7 @@ export class InactivityService extends BaseService implements IInactivityService
         await this.supabaseClient.auth.signOut();
       }
     } catch (error: any) {
-      console.error('[InactivityService] Error during idle logout:', error);
+      logger.error('InactivityService', 'Error during idle logout:', error);
     }
     
     // Call app callback for navigation/redirect
@@ -195,7 +196,7 @@ export class InactivityService extends BaseService implements IInactivityService
         await this.supabaseClient.auth.signOut();
       }
     } catch (error: any) {
-      console.error('[InactivityService] Error during manual sign out:', error);
+      logger.error('InactivityService', 'Error during manual sign out:', error);
     }
     
     // Call app callback for navigation/redirect
@@ -229,7 +230,7 @@ export class InactivityService extends BaseService implements IInactivityService
       const isProduction = import.meta.env.MODE === 'production';
       
       if (isProduction) {
-        console.warn('[InactivityService] Inactivity feature enabled in production');
+        logger.warn('InactivityService', 'Inactivity feature enabled in production');
       }
     }
   }
@@ -284,7 +285,7 @@ export class InactivityService extends BaseService implements IInactivityService
       // Set up event handlers
       this.setupEventHandlers();
     } catch (error) {
-      console.error('[InactivityService] Failed to setup inactivity tracker:', error);
+      logger.error('InactivityService', 'Failed to setup inactivity tracker:', error);
     }
   }
 

package/src/services/OrganisationService.ts

@@ -17,7 +17,8 @@ import type {
   OrganisationSecurityError,
   OrganisationHierarchy
 } from '../types/organisation';
-import { setOrganisationContext } from '../utils/organisationContext';
+import { setOrganisationContext } from '../utils/context/organisationContext';
+import { logger } from '../utils/core/logger';
 
 export class OrganisationService extends BaseService implements IOrganisationService {
   private _selectedOrganisation: Organisation | null = null;
@@ -254,14 +255,14 @@ export class OrganisationService extends BaseService implements IOrganisationSer
 
   private async setDatabaseOrganisationContext(organisation: Organisation): Promise<void> {
     if (!this.supabaseClient || !this.session) {
-      console.warn('[OrganisationService] No Supabase client or session available for setting organisation context');
+      logger.warn('OrganisationService', 'No Supabase client or session available for setting organisation context');
       this._isContextReady = false;
       this.notify();
       return;
     }
 
     try {
-      console.log('[OrganisationService] Setting database organisation context for:', organisation.id);
+      logger.debug('OrganisationService', 'Setting database organisation context for:', organisation.id);
       
       // Add timeout to prevent hanging
       const timeoutPromise = new Promise((_, reject) => {
@@ -272,11 +273,11 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       
       await Promise.race([contextPromise, timeoutPromise]);
       
-      console.log('[OrganisationService] Database organisation context set successfully');
+      logger.debug('OrganisationService', 'Database organisation context set successfully');
       this._isContextReady = true;
       this.notify();
     } catch (error) {
-      console.error('[OrganisationService] Failed to set database organisation context:', error);
+      logger.error('OrganisationService', 'Failed to set database organisation context:', error);
       // Set context ready to true anyway - this is a non-critical operation
       // The app should still work without database context
       this._isContextReady = true;
@@ -288,7 +289,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
   private async loadUserOrganisations(): Promise<void> {
     // Add call tracking to detect race conditions
     const callId = Math.random().toString(36).substr(2, 9);
-    console.log(`[OrganisationService] Starting loadUserOrganisations call ${callId}`);
+    logger.debug('OrganisationService', `Starting loadUserOrganisations call ${callId}`);
     
     if (!this.user || !this.session || !this.supabaseClient) {
       // Clear state when no user, session, or supabase client
@@ -303,7 +304,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
 
     // Additional check to prevent loading during auth state changes
     if (this.isLoadingRef) {
-      console.log("OrganisationService", "Already loading, skipping duplicate load");
+      logger.debug("OrganisationService", "Already loading, skipping duplicate load");
       // Ensure loading state is correct
       this._isLoading = true;
       this.notify();
@@ -313,7 +314,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     // Prevent rapid retries - minimum 2 seconds between attempts
     const now = Date.now();
     if (now - this.lastLoadTimeRef < 2000) {
-      console.log("OrganisationService", "Too soon since last load, skipping");
+      logger.debug("OrganisationService", "Too soon since last load, skipping");
       // Ensure loading state is correct
       if (this._organisations.length > 0 || this._selectedOrganisation) {
         this._isLoading = false;
@@ -340,7 +341,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     this.notify();
       
     try {
-      console.log("[OrganisationService] Supabase client ready:", {
+      logger.debug("OrganisationService", "Supabase client ready:", {
         isConnected: !!this.supabaseClient,
         hasAuth: !!this.supabaseClient.auth,
         hasRpc: !!this.supabaseClient.rpc
@@ -350,7 +351,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       // Only get actual members (org_admin, leader, member) - exclude supporters
       let memberships, membershipError;
       try {
-        console.log("[OrganisationService] Making RPC call to data_user_organisation_roles_get...");
+        logger.debug("OrganisationService", "Making RPC call to data_user_organisation_roles_get...");
         
         // Add timeout and abort signal to prevent hanging RPC calls
         const timeoutPromise = new Promise((_, reject) => {
@@ -373,7 +374,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
         
         const result = await Promise.race([rpcPromise, timeoutPromise]) as any;
         
-        console.log("[OrganisationService] RPC call completed:", {
+        logger.debug("OrganisationService", "RPC call completed:", {
           hasData: !!result.data,
           hasError: !!result.error,
           dataLength: result.data?.length || 0,
@@ -390,11 +391,11 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       }
 
       if (membershipError) {
-        console.error("[OrganisationService] Error loading memberships:", membershipError);
+        logger.error("OrganisationService", "Error loading memberships:", membershipError);
         
         // If RPC fails with timeout, try direct database query as fallback
         if (membershipError.message?.includes('timeout')) {
-          console.log("[OrganisationService] RPC timed out, trying direct database query as fallback...");
+          logger.debug("OrganisationService", "RPC timed out, trying direct database query as fallback...");
           try {
             // Check if request was aborted before making fallback query
             if (abortSignal.aborted) {
@@ -434,15 +435,15 @@ export class OrganisationService extends BaseService implements IOrganisationSer
               .in('role', ['org_admin', 'leader', 'member']);
             
             if (fallbackError) {
-              console.error("[OrganisationService] Fallback query also failed:", fallbackError);
+              logger.error("OrganisationService", "Fallback query also failed:", fallbackError);
               throw membershipError; // Throw original error
             }
             
-            console.log("[OrganisationService] Fallback query successful, got", fallbackData?.length || 0, "memberships");
+            logger.debug("OrganisationService", "Fallback query successful, got", fallbackData?.length || 0, "memberships");
             memberships = fallbackData || [];
             membershipError = null;
           } catch (fallbackErr) {
-            console.error("[OrganisationService] Fallback query failed:", fallbackErr);
+            logger.error("OrganisationService", "Fallback query failed:", fallbackErr);
             throw membershipError; // Throw original error
           }
         } else {
@@ -460,24 +461,24 @@ export class OrganisationService extends BaseService implements IOrganisationSer
         .filter((id: string) => {
           // Better validation to prevent empty string UUID errors
           if (!id || typeof id !== 'string') {
-            console.warn("[OrganisationService] Invalid organisation ID (not string):", id);
+            logger.warn("OrganisationService", "Invalid organisation ID (not string):", id);
             return false;
           }
           const trimmedId = id.trim();
           if (trimmedId === '') {
-            console.warn("[OrganisationService] Empty organisation ID found");
+            logger.warn("OrganisationService", "Empty organisation ID found");
             return false;
           }
           // Validate UUID format
           const isValidUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmedId);
           if (!isValidUuid) {
-            console.warn("[OrganisationService] Invalid UUID format:", trimmedId);
+            logger.warn("OrganisationService", "Invalid UUID format:", trimmedId);
           }
           return isValidUuid;
         });
       
       if (organisationIds.length === 0) {
-        console.warn("[OrganisationService] No valid organisation IDs found in memberships:", memberships);
+        logger.warn("OrganisationService", "No valid organisation IDs found in memberships:", memberships);
         throw new Error('No valid organisation IDs found in memberships') as OrganisationSecurityError;
       }
       
@@ -491,7 +492,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
         .select('id, name, display_name, subscription_tier, settings, is_active, parent_id, created_at, updated_at');
       
       if (orgError) {
-        console.error("[OrganisationService] Error loading organisations:", orgError);
+        logger.error("OrganisationService", "Error loading organisations:", orgError);
         throw orgError;
       }
       
@@ -534,16 +535,16 @@ export class OrganisationService extends BaseService implements IOrganisationSer
             if (validPersistedOrg) {
               initialOrg = validPersistedOrg;
             } else {
-              console.warn("[OrganisationService] Persisted organisation not found in active orgs, clearing cache");
+              logger.warn("OrganisationService", "Persisted organisation not found in active orgs, clearing cache");
               localStorage.removeItem('pace-core-selected-organisation');
             }
           } else {
-            console.warn("[OrganisationService] Invalid persisted organisation ID, clearing cache");
+            logger.warn("OrganisationService", "Invalid persisted organisation ID, clearing cache");
             localStorage.removeItem('pace-core-selected-organisation');
           }
         }
       } catch (storageError) {
-        console.warn("[OrganisationService] Failed to restore persisted organisation:", storageError);
+        logger.warn("OrganisationService", "Failed to restore persisted organisation:", storageError);
         // Clear potentially corrupted cache
         localStorage.removeItem('pace-core-selected-organisation');
       }
@@ -581,7 +582,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       this.hasFailedRef = false;
       
     } catch (err) {
-      console.error("[OrganisationService] Failed to load organisations:", err);
+      logger.error("OrganisationService", "Failed to load organisations:", err);
       this._error = err as Error;
       // Increment retry count on error
       this.retryCount = this.retryCount + 1;

package/src/services/__tests__/AuthService.test.ts

@@ -12,6 +12,17 @@ import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { AuthService } from '../AuthService';
 import { AuthError } from '@supabase/supabase-js';
 
+// Don't mock the logger - it now works in test mode
+// We'll spy on the Logger class methods in beforeEach to verify calls
+import { Logger } from '../../utils/core/logger';
+
+let mockLoggerFunctions: {
+  debug: ReturnType<typeof vi.spyOn>;
+  error: ReturnType<typeof vi.spyOn>;
+  warn: ReturnType<typeof vi.spyOn>;
+  info: ReturnType<typeof vi.spyOn>;
+};
+
 // Mock Supabase client
 const createMockSupabaseClient = () => ({
   auth: {
@@ -32,12 +43,25 @@ describe('AuthService', () => {
   let authService: AuthService;
 
   beforeEach(() => {
+    // Spy on Logger methods to verify calls (logger now works in test mode)
+    mockLoggerFunctions = {
+      debug: vi.spyOn(Logger, 'debug'),
+      error: vi.spyOn(Logger, 'error'),
+      warn: vi.spyOn(Logger, 'warn'),
+      info: vi.spyOn(Logger, 'info'),
+    };
+    
     mockSupabase = createMockSupabaseClient();
     authService = new AuthService(mockSupabase as any);
   });
 
   afterEach(() => {
     authService.cleanup();
+    // Restore spies
+    mockLoggerFunctions.debug.mockRestore();
+    mockLoggerFunctions.error.mockRestore();
+    mockLoggerFunctions.warn.mockRestore();
+    mockLoggerFunctions.info.mockRestore();
     vi.clearAllMocks();
   });
 
@@ -760,9 +784,9 @@ describe('AuthService', () => {
     it('should handle tracking errors gracefully without breaking authentication', async () => {
       const mockUser = { id: 'user-123', email: 'test@example.com' };
       const mockSession = { access_token: 'token', user: mockUser };
-      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
       
-      (mockSupabase as any).rpc.mockRejectedValue(new Error('Tracking failed'));
+      // Mock rpc to reject (this will trigger the catch block in trackSession)
+      (mockSupabase as any).rpc = vi.fn().mockRejectedValue(new Error('Tracking failed'));
       
       let authStateCallback: any;
       mockSupabase.auth.onAuthStateChange.mockImplementation((callback) => {
@@ -777,19 +801,29 @@ describe('AuthService', () => {
       if (authStateCallback) {
         authStateCallback('SIGNED_IN', mockSession);
         
-        // Wait a bit for async tracking to complete
-        await new Promise(resolve => setTimeout(resolve, 100));
+        // Wait for async tracking to complete (trackSession is async)
+        // The catch block in trackSession will log the error
+        // Note: The logger may be called in the .catch() handler with "Failed to track" 
+        // or in the catch block with "Error tracking"
+        await new Promise(resolve => setTimeout(resolve, 500));
         
-        // Verify error was logged but authentication still succeeded
-        // When rpc throws an exception, it goes to catch block which logs "Error tracking"
-        expect(consoleWarnSpy).toHaveBeenCalledWith(
-          expect.stringContaining('Error tracking login session'),
-          expect.anything()
+        // Check for either error message pattern
+        const warnCalls = mockLoggerFunctions.warn.mock.calls;
+        const hasErrorTracking = warnCalls.some(call => 
+          call[0] === 'AuthService' && 
+          typeof call[1] === 'string' && 
+          call[1].includes('Error tracking')
         );
+        const hasFailedToTrack = warnCalls.some(call => 
+          call[0] === 'AuthService' && 
+          typeof call[1] === 'string' && 
+          call[1].includes('Failed to track')
+        );
+        
+        expect(hasErrorTracking || hasFailedToTrack).toBe(true);
+        expect(mockLoggerFunctions.warn).toHaveBeenCalled();
         expect(authServiceWithApp.isAuthenticated()).toBe(true);
       }
-
-      consoleWarnSpy.mockRestore();
       authServiceWithApp.cleanup();
     });
 
@@ -1115,7 +1149,7 @@ describe('AuthService', () => {
     });
 
     it('should handle tracking when RPC fails', async () => {
-      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      vi.clearAllMocks();
       (mockSupabase as any).rpc = vi.fn().mockResolvedValue({
         error: { message: 'RPC failed' }
       });
@@ -1147,16 +1181,14 @@ describe('AuthService', () => {
       if (authStateCallback) {
         authStateCallback('SIGNED_IN', mockSession);
 
-        await new Promise(resolve => setTimeout(resolve, 100));
-
-        // Should log warning but not break authentication
-        expect(consoleWarnSpy).toHaveBeenCalledWith(
-          expect.stringContaining('Failed to track login session'),
+        // Wait for async tracking to complete
+        await new Promise(resolve => setTimeout(resolve, 200));
+        expect(mockLoggerFunctions.warn).toHaveBeenCalledWith(
+          'AuthService',
+          expect.stringContaining('Failed to track'),
           expect.anything()
         );
       }
-
-      consoleWarnSpy.mockRestore();
       authServiceWithApp.cleanup();
     });