unified-video-framework 1.4.157 → 1.4.159

package/src/analytics/core/DynamicAnalyticsManager.ts

@@ -0,0 +1,526 @@
+/**
+ * DynamicAnalyticsManager - Manages multiple analytics providers dynamically
+ * Supports different analytics systems including the player analytics API
+ */
+
+import { EventEmitter } from 'events';
+import { 
+  AnalyticsEvent,
+  PlayerState,
+  PlayerEventType,
+  PlayerSessionInfo
+} from '../types/AnalyticsTypes';
+import { PlayerAnalyticsAdapter, PlayerAnalyticsConfig } from '../adapters/PlayerAnalyticsAdapter';
+
+// Provider types enum
+export enum AnalyticsProviderType {
+  PLAYER_ANALYTICS = 'player_analytics',
+  CUSTOM = 'custom'
+}
+
+// Base interface for all analytics providers
+export interface BaseAnalyticsProvider {
+  startSession(videoInfo: any, customData?: any): string;
+  endSession(): Promise<void>;
+  trackEvent(event: any, playerState?: PlayerState, videoInfo?: any): void;
+  trackCustomEvent(eventType: string, data?: any): void;
+  flush(): Promise<void>;
+  getCurrentSession(): any;
+  destroy(): void;
+}
+
+// Configuration for different provider types
+export interface DynamicAnalyticsConfig {
+  enabled: boolean;
+  providers: Array<{
+    type: AnalyticsProviderType;
+    name: string;
+    config: any; // Provider-specific configuration
+    enabled: boolean;
+    priority?: number; // For ordering multiple providers
+  }>;
+  globalSettings?: {
+    enableConsoleLogging?: boolean;
+    enableErrorReporting?: boolean;
+    sessionTimeout?: number; // minutes
+  };
+}
+
+export class DynamicAnalyticsManager extends EventEmitter {
+  private config: DynamicAnalyticsConfig;
+  private providers: Map<string, BaseAnalyticsProvider> = new Map();
+  private activeSession: {
+    sessionId: string;
+    videoInfo: any;
+    startTime: number;
+    providers: string[];
+  } | null = null;
+  private sessionTimeout: NodeJS.Timeout | null = null;
+
+  constructor(config: DynamicAnalyticsConfig) {
+    super();
+    this.config = config;
+    this.initializeProviders();
+  }
+
+  /**
+   * Start a new analytics session across all enabled providers
+   */
+  public startSession(videoInfo: {
+    id: string;
+    title?: string;
+    type?: string;
+    duration?: number;
+    isLive?: boolean;
+    metadata?: Record<string, any>;
+  }, customData?: Record<string, any>): string {
+    if (!this.config.enabled) {
+      return 'disabled';
+    }
+
+    // End existing session if active
+    if (this.activeSession) {
+      this.endSession();
+    }
+
+    const sessionId = this.generateSessionId();
+    const enabledProviders: string[] = [];
+
+    // Start session on all enabled providers
+    for (const [name, provider] of this.providers) {
+      try {
+        const providerSessionId = provider.startSession(videoInfo, customData);
+        enabledProviders.push(name);
+        
+        this.log(`Started session on provider ${name}: ${providerSessionId}`);
+      } catch (error) {
+        this.handleError(`Failed to start session on provider ${name}`, error);
+      }
+    }
+
+    this.activeSession = {
+      sessionId,
+      videoInfo,
+      startTime: Date.now(),
+      providers: enabledProviders
+    };
+
+    // Set session timeout if configured
+    if (this.config.globalSettings?.sessionTimeout) {
+      this.setSessionTimeout();
+    }
+
+    this.emit('sessionStart', {
+      sessionId,
+      videoInfo,
+      providers: enabledProviders
+    });
+
+    return sessionId;
+  }
+
+  /**
+   * End the current analytics session
+   */
+  public async endSession(): Promise<void> {
+    if (!this.activeSession) {
+      return;
+    }
+
+    const { sessionId, providers } = this.activeSession;
+
+    // Clear session timeout
+    if (this.sessionTimeout) {
+      clearTimeout(this.sessionTimeout);
+      this.sessionTimeout = null;
+    }
+
+    // End session on all active providers
+    const endPromises = providers.map(async (name) => {
+      const provider = this.providers.get(name);
+      if (provider) {
+        try {
+          await provider.endSession();
+          this.log(`Ended session on provider ${name}`);
+        } catch (error) {
+          this.handleError(`Failed to end session on provider ${name}`, error);
+        }
+      }
+    });
+
+    await Promise.allSettled(endPromises);
+
+    this.emit('sessionEnd', {
+      sessionId,
+      duration: Date.now() - this.activeSession.startTime,
+      providers
+    });
+
+    this.activeSession = null;
+  }
+
+  /**
+   * Track an analytics event across all providers
+   */
+  public trackEvent(
+    eventType: PlayerEventType,
+    playerState: PlayerState,
+    additionalData?: Record<string, any>
+  ): void {
+    if (!this.config.enabled || !this.activeSession) {
+      return;
+    }
+
+    const event: AnalyticsEvent = {
+      eventId: this.generateEventId(),
+      eventType,
+      timestamp: Date.now(),
+      sessionId: this.activeSession.sessionId,
+      videoId: this.activeSession.videoInfo.id,
+      currentTime: playerState.currentTime,
+      duration: playerState.duration,
+      ...additionalData
+    } as AnalyticsEvent;
+
+    // Track on all active providers
+    for (const providerName of this.activeSession.providers) {
+      const provider = this.providers.get(providerName);
+      if (provider) {
+        try {
+          provider.trackEvent(event, playerState, this.activeSession.videoInfo);
+        } catch (error) {
+          this.handleError(`Failed to track event on provider ${providerName}`, error);
+        }
+      }
+    }
+
+    this.emit('eventTracked', {
+      event,
+      providers: this.activeSession.providers
+    });
+  }
+
+  /**
+   * Track a custom event
+   */
+  public trackCustomEvent(eventType: string, data?: Record<string, any>): void {
+    if (!this.config.enabled || !this.activeSession) {
+      return;
+    }
+
+    // Track on all active providers
+    for (const providerName of this.activeSession.providers) {
+      const provider = this.providers.get(providerName);
+      if (provider) {
+        try {
+          provider.trackCustomEvent(eventType, data);
+        } catch (error) {
+          this.handleError(`Failed to track custom event on provider ${providerName}`, error);
+        }
+      }
+    }
+
+    this.emit('customEventTracked', {
+      eventType,
+      data,
+      providers: this.activeSession.providers
+    });
+  }
+
+  /**
+   * Flush all pending events across providers
+   */
+  public async flush(): Promise<void> {
+    if (!this.activeSession) {
+      return;
+    }
+
+    const flushPromises = this.activeSession.providers.map(async (name) => {
+      const provider = this.providers.get(name);
+      if (provider) {
+        try {
+          await provider.flush();
+          this.log(`Flushed events for provider ${name}`);
+        } catch (error) {
+          this.handleError(`Failed to flush events for provider ${name}`, error);
+        }
+      }
+    });
+
+    await Promise.allSettled(flushPromises);
+  }
+
+  /**
+   * Add a new analytics provider dynamically
+   */
+  public addProvider(
+    name: string, 
+    type: AnalyticsProviderType, 
+    config: any, 
+    enabled: boolean = true
+  ): void {
+    try {
+      const provider = this.createProvider(type, config);
+      this.providers.set(name, provider);
+
+      this.log(`Added provider ${name} of type ${type}`);
+      
+      // If there's an active session, start it on the new provider
+      if (enabled && this.activeSession) {
+        provider.startSession(this.activeSession.videoInfo);
+        this.activeSession.providers.push(name);
+      }
+
+      this.emit('providerAdded', { name, type, enabled });
+    } catch (error) {
+      this.handleError(`Failed to add provider ${name}`, error);
+    }
+  }
+
+  /**
+   * Remove an analytics provider
+   */
+  public async removeProvider(name: string): Promise<void> {
+    const provider = this.providers.get(name);
+    if (!provider) {
+      return;
+    }
+
+    try {
+      // End session on this provider if active
+      if (this.activeSession && this.activeSession.providers.includes(name)) {
+        await provider.endSession();
+        this.activeSession.providers = this.activeSession.providers.filter(p => p !== name);
+      }
+
+      // Destroy the provider
+      provider.destroy();
+      this.providers.delete(name);
+
+      this.log(`Removed provider ${name}`);
+      this.emit('providerRemoved', { name });
+    } catch (error) {
+      this.handleError(`Failed to remove provider ${name}`, error);
+    }
+  }
+
+  /**
+   * Enable or disable a provider
+   */
+  public toggleProvider(name: string, enabled: boolean): void {
+    const provider = this.providers.get(name);
+    if (!provider) {
+      this.log(`Provider ${name} not found`);
+      return;
+    }
+
+    if (this.activeSession) {
+      if (enabled && !this.activeSession.providers.includes(name)) {
+        // Enable: start session on this provider
+        try {
+          provider.startSession(this.activeSession.videoInfo);
+          this.activeSession.providers.push(name);
+        } catch (error) {
+          this.handleError(`Failed to enable provider ${name}`, error);
+        }
+      } else if (!enabled && this.activeSession.providers.includes(name)) {
+        // Disable: end session on this provider
+        try {
+          provider.endSession();
+          this.activeSession.providers = this.activeSession.providers.filter(p => p !== name);
+        } catch (error) {
+          this.handleError(`Failed to disable provider ${name}`, error);
+        }
+      }
+    }
+
+    this.emit('providerToggled', { name, enabled });
+  }
+
+  /**
+   * Get current session information
+   */
+  public getCurrentSession(): any {
+    return this.activeSession;
+  }
+
+  /**
+   * Get analytics statistics
+   */
+  public getStats(): {
+    enabled: boolean;
+    totalProviders: number;
+    activeProviders: number;
+    currentSession: any;
+    providers: Array<{
+      name: string;
+      type: string;
+      active: boolean;
+      sessionInfo?: any;
+    }>;
+  } {
+    const providerStats = Array.from(this.providers.entries()).map(([name, provider]) => ({
+      name,
+      type: this.getProviderType(name),
+      active: this.activeSession?.providers.includes(name) || false,
+      sessionInfo: provider.getCurrentSession()
+    }));
+
+    return {
+      enabled: this.config.enabled,
+      totalProviders: this.providers.size,
+      activeProviders: this.activeSession?.providers.length || 0,
+      currentSession: this.activeSession,
+      providers: providerStats
+    };
+  }
+
+  /**
+   * Update configuration
+   */
+  public updateConfig(newConfig: Partial<DynamicAnalyticsConfig>): void {
+    this.config = { ...this.config, ...newConfig };
+    
+    if (!this.config.enabled && this.activeSession) {
+      // Disable analytics if turned off
+      this.endSession();
+    }
+
+    this.emit('configUpdated', this.config);
+  }
+
+  /**
+   * Destroy the analytics manager
+   */
+  public destroy(): void {
+    // End active session
+    if (this.activeSession) {
+      this.endSession();
+    }
+
+    // Destroy all providers
+    for (const [name, provider] of this.providers) {
+      try {
+        provider.destroy();
+      } catch (error) {
+        this.handleError(`Error destroying provider ${name}`, error);
+      }
+    }
+
+    this.providers.clear();
+    this.removeAllListeners();
+  }
+
+  // Private methods
+
+  private initializeProviders(): void {
+    if (!this.config.enabled) {
+      return;
+    }
+
+    // Sort providers by priority
+    const sortedProviders = [...this.config.providers].sort((a, b) => {
+      return (a.priority || 0) - (b.priority || 0);
+    });
+
+    for (const providerConfig of sortedProviders) {
+      if (providerConfig.enabled) {
+        try {
+          const provider = this.createProvider(providerConfig.type, providerConfig.config);
+          this.providers.set(providerConfig.name, provider);
+          this.log(`Initialized provider ${providerConfig.name}`);
+        } catch (error) {
+          this.handleError(`Failed to initialize provider ${providerConfig.name}`, error);
+        }
+      }
+    }
+  }
+
+  private createProvider(type: AnalyticsProviderType, config: any): BaseAnalyticsProvider {
+    switch (type) {
+      case AnalyticsProviderType.PLAYER_ANALYTICS:
+        return new PlayerAnalyticsAdapter(config as PlayerAnalyticsConfig);
+      
+      case AnalyticsProviderType.CUSTOM:
+        // For custom providers, expect a factory function in config
+        if (typeof config.factory !== 'function') {
+          throw new Error('Custom provider must include a factory function');
+        }
+        return config.factory(config);
+      
+      default:
+        throw new Error(`Unsupported provider type: ${type}`);
+    }
+  }
+
+  private getProviderType(name: string): string {
+    const providerConfig = this.config.providers.find(p => p.name === name);
+    return providerConfig?.type || 'unknown';
+  }
+
+  private setSessionTimeout(): void {
+    if (this.sessionTimeout) {
+      clearTimeout(this.sessionTimeout);
+    }
+
+    const timeoutMs = (this.config.globalSettings!.sessionTimeout! * 60 * 1000);
+    this.sessionTimeout = setTimeout(() => {
+      this.log('Session timeout reached, ending session');
+      this.endSession();
+    }, timeoutMs);
+  }
+
+  private log(message: string): void {
+    if (this.config.globalSettings?.enableConsoleLogging) {
+      console.log(`[DynamicAnalyticsManager] ${message}`);
+    }
+  }
+
+  private handleError(message: string, error: any): void {
+    const errorMessage = `${message}: ${error?.message || error}`;
+    
+    if (this.config.globalSettings?.enableConsoleLogging) {
+      console.error(`[DynamicAnalyticsManager] ${errorMessage}`);
+    }
+
+    if (this.config.globalSettings?.enableErrorReporting) {
+      this.emit('error', { message: errorMessage, error });
+    }
+  }
+
+  private generateSessionId(): string {
+    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private generateEventId(): string {
+    return `event_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+}
+
+// Factory function
+export function createDynamicAnalyticsManager(config: DynamicAnalyticsConfig): DynamicAnalyticsManager {
+  return new DynamicAnalyticsManager(config);
+}
+
+// Helper function to create player analytics provider config
+export function createPlayerAnalyticsProviderConfig(
+  baseUrl: string,
+  apiKey: string,
+  playerId: string,
+  options?: {
+    tenantId?: string;
+    heartbeatInterval?: number;
+    batchSize?: number;
+    flushInterval?: number;
+  }
+): PlayerAnalyticsConfig {
+  return {
+    baseUrl,
+    apiKey,
+    playerId,
+    tenantId: options?.tenantId,
+    heartbeatInterval: options?.heartbeatInterval || 10,
+    batchSize: options?.batchSize || 10,
+    flushInterval: options?.flushInterval || 30
+  };
+}