Fix MetricsManager

Author: ivantha

browser-extension/src/content/index.ts

@@ -7,6 +7,7 @@ import { initializeGlobalGate, protectedExecute } from '@/shared/InitializationG
 import { createNavigationWatcher } from './utils/NavigationWatcher';
 import { isInAllowedGroupNow } from '@/content/utils/group';
 import { log, error } from '@/shared/logger';
+import { metricsManager } from './metrics/MetricsManager';
 
 declare const __DEV__: boolean;
 if (!__DEV__) {
@@ -30,6 +31,10 @@ async function initializeExtensionFeatures(): Promise<void> {
     await protectedExecute(async () => {
       log('Initializing extension features');
 
+      // Initialize MetricsManager first (uses existing validated session)
+      await metricsManager.initialize();
+      log('MetricsManager initialized');
+      
       // Create post observer (but don't start processing yet)
       postObserver = new FacebookPostObserver();
 
@@ -89,6 +94,11 @@ function cleanupExtension(): void {
     chatWindow = null;
   }
 
+  // Clean up MetricsManager
+  metricsManager.destroy().catch(err => {
+    error('Failed to destroy MetricsManager:', err);
+  });
+  
   analytics.setEnabled(false);
   log('Extension resources cleaned up');
 }

browser-extension/src/content/metrics/AnalyticsEventCollector.ts

@@ -1,5 +1,5 @@
 import { analytics } from '@/shared/analytics';
-import type { EventBatchRequest, UnifiedAnalyticsEvent, MetricsConfig, ScrollMetrics } from '@/shared/types';
+import type { EventBatchRequest, UnifiedAnalyticsEvent, MetricsConfig, ScrollMetrics, EventCategory } from '@/shared/types';
 import { sendAnalyticsEvents } from '../messaging';
 import { ComprehensiveAnalyticsManager } from './ComprehensiveAnalyticsManager';
 
@@ -39,7 +39,7 @@ export class AnalyticsEventCollector {
 
   public trackEvent(
     eventType: string,
-    category: 'session' | 'post' | 'chat' | 'interaction' | 'performance',
+    category: EventCategory,
     data: Record<string, unknown>,
     postId?: string
   ): void {

browser-extension/src/content/metrics/MetricsManager.ts

@@ -5,11 +5,11 @@
 import { log, error } from '../../shared/logger';
 import { AnalyticsEventCollector } from './AnalyticsEventCollector';
 import { ComprehensiveAnalyticsManager } from './ComprehensiveAnalyticsManager';
-import { MetricsConfig, UserSession } from '../../shared/types';
-import { verifyAndInitializeUserSession } from '../utils/initialization';
+import { MetricsConfig, UserSession, EventCategory } from '../../shared/types';
 import { analytics } from '@/shared/analytics';
 import { getSessionHiddenTimeoutMs } from '@/shared/env';
 import { isInAllowedGroupNow } from '@/content/utils/group';
+import { requireGlobalInitialization, protectedExecute } from '@/shared/InitializationGate';
 
 export class MetricsManager {
   private rawCollector: AnalyticsEventCollector | null = null;
@@ -29,20 +29,17 @@ export class MetricsManager {
     if (this.isInitialized) return;
 
     try {
-      // CRITICAL: Verify and initialize user/session BEFORE any analytics or post processing
-      const { userId: backendUserId, sessionId: backendSessionId, isNewUser, isNewSession } = 
-        await verifyAndInitializeUserSession();
+      // Get session data from centralized SessionManager via InitializationGate
+      const sessionData = requireGlobalInitialization();
 
-      log('User/Session verified and initialized', { 
-        userId: backendUserId, 
-        sessionId: backendSessionId,
-        isNewUser,
-        isNewSession 
+      log('Using existing validated session for MetricsManager', { 
+        userId: sessionData.userId, 
+        sessionId: sessionData.sessionId
       });
 
       this.session = {
-        userId: backendUserId,
-        sessionId: backendSessionId,
+        userId: sessionData.userId,
+        sessionId: sessionData.sessionId,
         startTime: Date.now(),
         lastActivity: Date.now(),
       };
@@ -56,15 +53,15 @@ export class MetricsManager {
 
       // Initialize analytics event collector (legacy support)
       this.rawCollector = new AnalyticsEventCollector(config);
-      this.rawCollector.setSession(backendUserId, backendSessionId);
+      this.rawCollector.setSession(sessionData.userId, sessionData.sessionId);
 
       // Initialize comprehensive analytics system
-      this.comprehensiveAnalytics = new ComprehensiveAnalyticsManager(backendUserId, backendSessionId);
+      this.comprehensiveAnalytics = new ComprehensiveAnalyticsManager(sessionData.userId, sessionData.sessionId);
 
       // Hook Mixpanel identity and super props
-      analytics.identify(backendUserId);
+      analytics.identify(sessionData.userId);
       analytics.registerSuper({
-        session_id: backendSessionId,
+        session_id: sessionData.sessionId,
         platform: 'chrome_extension',
         environment: process.env.NODE_ENV || 'production',
       });
@@ -104,7 +101,7 @@ export class MetricsManager {
       this.setupPageLifecycle();
 
       this.isInitialized = true;
-      log('MetricsManager initialized', { userId: backendUserId, sessionId: backendSessionId });
+      log('MetricsManager initialized', { userId: sessionData.userId, sessionId: sessionData.sessionId });
     } catch (err) {
       error('Failed to initialize MetricsManager:', err);
     }
@@ -117,23 +114,29 @@ export class MetricsManager {
     label?: string;
     metadata?: Record<string, unknown>;
   }): void {
-    if (!this.session || !this.rawCollector) {
-      log('MetricsManager not initialized, skipping event:', event.type);
-      return;
-    }
+    // Use protectedExecute to ensure tracking only happens with valid session
+    protectedExecute(async () => {
+      if (!this.session || !this.rawCollector) {
+        log('MetricsManager not initialized, skipping event:', event.type);
+        return;
+      }
 
-    this.updateLastActivity();
-    // Route to unified analytics event collector
-    const data: Record<string, unknown> = {
-      ...(event.metadata || {}),
-    };
-    if (typeof event.value !== 'undefined') data.value = event.value;
-    if (typeof event.label !== 'undefined') data.label = event.label;
-    this.rawCollector.trackEvent(
-      event.type,
-      event.category as 'session' | 'post' | 'chat' | 'interaction' | 'performance',
-      data,
-    );
+      this.updateLastActivity();
+      // Route to unified analytics event collector
+      const data: Record<string, unknown> = {
+        ...(event.metadata || {}),
+      };
+      if (typeof event.value !== 'undefined') data.value = event.value;
+      if (typeof event.label !== 'undefined') data.label = event.label;
+      this.rawCollector.trackEvent(
+        event.type,
+        event.category as EventCategory,
+        data,
+      );
+    }, `trackEvent:${event.type}`).catch(err => {
+      // Non-blocking: metrics tracking failure shouldn't break the app
+      log('Failed to track event:', event.type, err);
+    });
   }
 
   public trackPostView(postId: string, postElement: Element): void {

browser-extension/src/shared/SessionManager.ts

@@ -5,7 +5,7 @@
 
 import { STORAGE_KEYS } from './constants';
 import { log, error } from './logger';
-import { UserSessionInfo } from '../content/utils/initialization';
+import type { UserSessionInfo } from '../content/utils/initialization';
 
 export interface SessionManagerConfig {
   requireValidSession: boolean;

browser-extension/src/shared/types.ts

@@ -61,7 +61,8 @@ export type EventCategory =
   | 'trust'
   | 'ui'
   | 'content'
-  | 'learning';
+  | 'learning'
+  | 'error';
 
 export type EventPriority = 'critical' | 'high' | 'medium' | 'low';