unified-video-framework 1.4.159 → 1.4.160

package/src/analytics/core/DynamicAnalyticsManager.ts

@@ -1,526 +0,0 @@
-/**
- * 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
-  };
-}