Analytics Dashboard

data_flow:
  collection:
    - user_interactions
    - page_views
    - quiz_attempts
    - video_watch_time
    - search_queries
    - feedback_submissions

  processing:
    - event_streaming
    - real_time_aggregation
    - sentiment_analysis
    - pattern_detection
    - anomaly_detection

  storage:
    - time_series_db
    - analytics_warehouse
    - cache_layer
    - backup_system

  visualization:
    - real_time_dashboards
    - custom_reports
    - alert_system
    - export_functionality

class EngagementAnalytics {
  constructor() {
    this.metrics = {
      activeUsers: new Map(),
      sessionDuration: new Map(),
      pageViews: new Map(),
      interactions: new Map(),
      bounceRate: new Map()
    };
  }

  trackUserActivity(userId, activity) {
    const timestamp = Date.now();
    const userMetrics = this.getOrCreateUserMetrics(userId);

    switch (activity.type) {
      case 'page_view':
        this.trackPageView(userMetrics, activity.data);
        break;
      case 'interaction':
        this.trackInteraction(userMetrics, activity.data);
        break;
      case 'quiz_attempt':
        this.trackQuizActivity(userMetrics, activity.data);
        break;
      case 'video_watch':
        this.trackVideoEngagement(userMetrics, activity.data);
        break;
    }

    this.updateRealTimeMetrics(userId, userMetrics);
  }

  trackPageView(userMetrics, data) {
    userMetrics.pageViews.push({
      timestamp: Date.now(),
      page: data.page,
      duration: 0,
      topic: data.topic,
      examType: data.examType
    });

    // Track time on previous page
    if (userMetrics.pageViews.length > 1) {
      const prevPage = userMetrics.pageViews[userMetrics.pageViews.length - 2];
      prevPage.duration = Date.now() - prevPage.timestamp;
    }

    // Update topic engagement
    if (data.topic) {
      userMetrics.topicEngagement[data.topic] =
        (userMetrics.topicEngagement[data.topic] || 0) + 1;
    }
  }

  calculateEngagementScore(userId) {
    const userMetrics = this.metrics.activeUsers.get(userId);
    if (!userMetrics) return 0;

    const weights = {
      pageViews: 0.2,
      sessionDuration: 0.3,
      interactions: 0.25,
      quizPerformance: 0.15,
      consistency: 0.1
    };

    const normalizedMetrics = {
      pageViews: Math.min(userMetrics.pageViews.length / 10, 1),
      sessionDuration: Math.min(userMetrics.totalSessionTime / 3600000, 1), // 1 hour max
      interactions: Math.min(userMetrics.interactions.length / 20, 1),
      quizPerformance: userMetrics.averageQuizScore / 100,
      consistency: this.calculateConsistencyScore(userMetrics)
    };

    return Object.entries(weights).reduce((score, [metric, weight]) => {
      return score + (normalizedMetrics[metric] * weight);
    }, 0);
  }
}

<div class="analytics-dashboard">
  <!-- Real-time Overview -->
  <section class="real-time-metrics">
    <h2>Live Platform Activity</h2>
    <div class="metric-cards">
      <div class="metric-card">
        <h3>Active Users</h3>
        <div class="metric-value" id="active-users">0</div>
        <div class="metric-change" id="active-users-change">+0%</div>
      </div>

      <div class="metric-card">
        <h3>Current Sessions</h3>
        <div class="metric-value" id="current-sessions">0</div>
        <div class="metric-change" id="sessions-change">+0%</div>
      </div>

      <div class="metric-card">
        <h3>Avg. Session Duration</h3>
        <div class="metric-value" id="avg-duration">0m</div>
        <div class="metric-change" id="duration-change">+0%</div>
      </div>

      <div class="metric-card">
        <h3>Engagement Rate</h3>
        <div class="metric-value" id="engagement-rate">0%</div>
        <div class="metric-change" id="engagement-change">+0%</div>
      </div>
    </div>
  </section>

  <!-- Geographic Distribution -->
  <section class="geographic-analytics">
    <h2>User Distribution by Location</h2>
    <div class="map-container">
      <div id="user-map" class="interactive-map"></div>
      <div class="location-stats">
        <table id="top-locations">
          <thead>
            <tr><th>Location</th><th>Users</th><th>Growth</th></tr>
          </thead>
          <tbody></tbody>
        </table>
      </div>
    </div>
  </section>

  <!-- Content Heatmap -->
  <section class="content-analytics">
    <h2>Content Engagement Heatmap</h2>
    <div class="heatmap-container">
      <div id="content-heatmap"></div>
      <div class="heatmap-controls">
        <select id="heatmap-dimension">
          <option value="page_views">Page Views</option>
          <option value="time_spent">Time Spent</option>
          <option value="completion_rate">Completion Rate</option>
          <option value="quiz_performance">Quiz Performance</option>
        </select>
        <select id="heatmap-exam">
          <option value="all">All Exams</option>
          <option value="ibps-po">IBPS PO</option>
          <option value="ibps-clerk">IBPS Clerk</option>
        </select>
      </div>
    </div>
  </section>
</div>

class LearningProgressAnalytics {
  constructor() {
    this.progressData = new Map();
    this.learningPaths = new Map();
    this.milestones = new Map();
  }

  trackProgress(userId, progressUpdate) {
    const userProgress = this.getOrCreateProgress(userId);

    // Update topic mastery
    if (progressUpdate.topic) {
      this.updateTopicMastery(userProgress, progressUpdate);
    }

    // Update learning path progress
    if (progressUpdate.pathId) {
      this.updatePathProgress(userProgress, progressUpdate);
    }

    // Check for milestone achievements
    this.checkMilestones(userProgress);

    // Calculate learning velocity
    this.updateLearningVelocity(userProgress);

    // Generate insights
    return this.generateProgressInsights(userProgress);
  }

  updateTopicMastery(userProgress, update) {
    const topic = update.topic;
    if (!userProgress.topicMastery[topic]) {
      userProgress.topicMastery[topic] = {
        level: 0,
        confidence: 0,
        practiceTime: 0,
        quizScores: [],
        lastAccessed: null
      };
    }

    const mastery = userProgress.topicMastery[topic];

    // Update based on activity type
    switch (update.activity) {
      case 'theory_completed':
        mastery.level = Math.max(mastery.level, 1);
        break;
      case 'practice_completed':
        mastery.level = Math.max(mastery.level, 2);
        break;
      case 'quiz_passed':
        mastery.quizScores.push(update.score);
        mastery.level = Math.max(mastery.level, 3);
        break;
      case 'revision_completed':
        mastery.level = Math.max(mastery.level, 4);
        break;
    }

    // Calculate confidence based on consistency
    mastery.confidence = this.calculateConfidence(mastery.quizScores);
    mastery.practiceTime += update.timeSpent || 0;
    mastery.lastAccessed = new Date();
  }

  generateProgressInsights(userProgress) {
    const insights = [];

    // Learning velocity analysis
    if (userProgress.learningVelocity < 0.5) {
      insights.push({
        type: 'warning',
        message: 'Learning pace is slower than recommended',
        suggestion: 'Consider increasing daily study time or focusing on weaker areas',
        priority: 'medium'
      });
    }

    // Strengths and weaknesses
    const analysis = this.analyzeStrengthsWeaknesses(userProgress);
    if (analysis.weaknesses.length > 0) {
      insights.push({
        type: 'improvement',
        message: `Focus areas: ${analysis.weaknesses.slice(0, 3).join(', ')}`,
        suggestion: 'Dedicate extra practice time to these topics',
        priority: 'high'
      });
    }

    // Progress consistency
    const consistency = this.calculateConsistency(userProgress);
    if (consistency < 0.7) {
      insights.push({
        type: 'consistency',
        message: 'Study consistency could be improved',
        suggestion: 'Try to maintain a regular study schedule',
        priority: 'medium'
      });
    }

    return insights;
  }

  generateProgressReport(userId, timeRange) {
    const userProgress = this.progressData.get(userId);
    if (!userProgress) return null;

    return {
      summary: {
        overallProgress: this.calculateOverallProgress(userProgress),
        learningVelocity: userProgress.learningVelocity,
        studyStreak: userProgress.studyStreak,
        totalStudyTime: userProgress.totalStudyTime
      },
      topicMastery: userProgress.topicMastery,
      strengths: this.identifyStrengths(userProgress),
      improvementAreas: this.identifyImprovementAreas(userProgress),
      recommendations: this.generatePersonalizedRecommendations(userProgress),
      achievements: userProgress.achievements,
      nextMilestones: this.getNextMilestones(userProgress)
    };
  }
}

<section class="learning-analytics">
  <h2>Student Learning Progress</h2>

  <!-- Progress Overview -->
  <div class="progress-overview">
    <div class="progress-cards">
      <div class="progress-card">
        <h3>Overall Progress</h3>
        <div class="circular-progress" id="overall-progress">
          <svg width="120" height="120">
            <circle class="progress-bg" cx="60" cy="60" r="50"></circle>
            <circle class="progress-bar" cx="60" cy="60" r="50"></circle>
          </svg>
          <div class="progress-text">0%</div>
        </div>
      </div>

      <div class="progress-card">
        <h3>Study Streak</h3>
        <div class="streak-display">
          <span class="streak-number">0</span>
          <span class="streak-unit">days</span>
          <div class="streak-fire">🔥</div>
        </div>
      </div>

      <div class="progress-card">
        <h3>Learning Velocity</h3>
        <div class="velocity-gauge">
          <div class="gauge-value">0.0</div>
          <div class="gauge-label">topics/week</div>
        </div>
      </div>
    </div>
  </div>

  <!-- Topic Mastery Heatmap -->
  <div class="topic-mastery-heatmap">
    <h3>Topic Mastery Overview</h3>
    <div class="heatmap-grid" id="mastery-heatmap">
      <!-- Dynamic generation based on user progress -->
    </div>
    <div class="mastery-legend">
      <span class="legend-item mastery-1">Beginner</span>
      <span class="legend-item mastery-2">Developing</span>
      <span class="legend-item mastery-3">Proficient</span>
      <span class="legend-item mastery-4">Advanced</span>
    </div>
  </div>

  <!-- Learning Path Progress -->
  <div class="learning-path-progress">
    <h3>Learning Path Progress</h3>
    <div class="path-visualization">
      <div class="path-nodes" id="path-nodes">
        <!-- Dynamic path nodes based on selected learning path -->
      </div>
    </div>
  </div>
</section>

class ContentPerformanceAnalytics {
  constructor() {
    this.contentMetrics = new Map();
    this.userInteractionTracking = new Map();
    this.performanceThresholds = {
      lowEngagement: 0.3,
      highBounceRate: 0.7,
      lowCompletion: 0.4,
      poorRating: 2.5
    };
  }

  trackContentInteraction(contentId, interaction) {
    if (!this.contentMetrics.has(contentId)) {
      this.contentMetrics.set(contentId, {
        views: 0,
        uniqueViews: new Set(),
        totalTimeSpent: 0,
        averageTimeSpent: 0,
        completionRate: 0,
        bounceRate: 0,
        interactions: [],
        ratings: [],
        feedback: [],
        conversions: 0
      });
    }

    const metrics = this.contentMetrics.get(contentId);

    switch (interaction.type) {
      case 'view':
        metrics.views++;
        metrics.uniqueViews.add(interaction.userId);
        break;

      case 'time_spent':
        metrics.totalTimeSpent += interaction.duration;
        metrics.averageTimeSpent = metrics.totalTimeSpent / metrics.views;
        break;

      case 'completion':
        this.updateCompletionRate(contentId, interaction);
        break;

      case 'bounce':
        this.updateBounceRate(contentId, interaction);
        break;

      case 'rating':
        metrics.ratings.push(interaction.rating);
        break;

      case 'conversion':
        metrics.conversions++;
        break;
    }

    this.analyzePerformance(contentId);
  }

  analyzePerformance(contentId) {
    const metrics = this.contentMetrics.get(contentId);
    const analysis = {
      performance: 'good',
      issues: [],
      recommendations: [],
      score: this.calculatePerformanceScore(metrics)
    };

    // Check for performance issues
    if (metrics.averageTimeSpent < 30000) { // Less than 30 seconds
      analysis.issues.push('Low engagement time');
      analysis.recommendations.push('Improve content introduction and hooks');
    }

    if (metrics.bounceRate > this.performanceThresholds.highBounceRate) {
      analysis.issues.push('High bounce rate');
      analysis.recommendations.push('Review content structure and navigation');
    }

    if (metrics.completionRate < this.performanceThresholds.lowCompletion) {
      analysis.issues.push('Low completion rate');
      analysis.recommendations.push('Check content length and difficulty progression');
    }

    const avgRating = metrics.ratings.reduce((a, b) => a + b, 0) / metrics.ratings.length;
    if (avgRating < this.performanceThresholds.poorRating) {
      analysis.issues.push('Poor user ratings');
      analysis.recommendations.push('Address user feedback and content quality');
    }

    // Determine overall performance
    if (analysis.issues.length > 0) {
      analysis.performance = analysis.score < 50 ? 'poor' : 'needs_improvement';
    } else if (analysis.score > 80) {
      analysis.performance = 'excellent';
    }

    return analysis;
  }

  generateContentReport(contentId, timeRange) {
    const metrics = this.contentMetrics.get(contentId);
    const analysis = this.analyzePerformance(contentId);

    return {
      contentId: contentId,
      period: timeRange,
      metrics: {
        views: metrics.views,
        uniqueViews: metrics.uniqueViews.size,
        averageTimeSpent: metrics.averageTimeSpent,
        completionRate: metrics.completionRate,
        bounceRate: metrics.bounceRate,
        averageRating: this.calculateAverageRating(metrics.ratings),
        conversionRate: this.calculateConversionRate(metrics)
      },
      analysis: analysis,
      trends: this.calculateTrends(contentId, timeRange),
      userSegments: this.analyzeUserSegments(contentId),
      recommendations: this.generateContentRecommendations(analysis)
    };
  }
}

<section class="content-performance">
  <h2>Content Performance Analysis</h2>

  <!-- Content Ranking Table -->
  <div class="content-ranking">
    <h3>Top Performing Content</h3>
    <div class="ranking-controls">
      <select id="ranking-metric">
        <option value="engagement">Engagement</option>
        <option value="completion">Completion Rate</option>
        <option value="rating">User Rating</option>
        <option value="conversion">Conversion</option>
      </select>
      <select id="ranking-period">
        <option value="7d">Last 7 Days</option>
        <option value="30d">Last 30 Days</option>
        <option value="90d">Last 90 Days</option>
      </select>
    </div>

    <table class="ranking-table">
      <thead>
        <tr>
          <th>Content</th>
          <th>Views</th>
          <th>Engagement</th>
          <th>Completion</th>
          <th>Rating</th>
          <th>Trend</th>
        </tr>
      </thead>
      <tbody id="ranking-tbody">
        <!-- Dynamically populated -->
      </tbody>
    </table>
  </div>

  <!-- Content Comparison -->
  <div class="content-comparison">
    <h3>Content Comparison</h3>
    <div class="comparison-controls">
      <div class="content-selector">
        <label>Compare:</label>
        <select id="content-compare-1" multiple>
          <!-- Dynamically populated with content options -->
        </select>
      </div>
      <div class="metric-selector">
        <label>Metrics:</label>
        <div class="metric-checkboxes">
          <label><input type="checkbox" value="views" checked> Views</label>
          <label><input type="checkbox" value="time"> Time Spent</label>
          <label><input type="checkbox" value="completion"> Completion</label>
          <label><input type="checkbox" value="rating"> Rating</label>
        </div>
      </div>
    </div>

    <div class="comparison-chart">
      <canvas id="content-comparison-chart"></canvas>
    </div>
  </div>

  <!-- Content Issues -->
  <div class="content-issues">
    <h3>Content Requiring Attention</h3>
    <div class="issues-grid">
      <div class="issue-card low-engagement">
        <h4>Low Engagement</h4>
        <div class="issue-count" id="low-engagement-count">0</div>
        <div class="issue-items" id="low-engagement-items">
          <!-- List of content with low engagement -->
        </div>
      </div>

      <div class="issue-card high-bounce">
        <h4>High Bounce Rate</h4>
        <div class="issue-count" id="high-bounce-count">0</div>
        <div class="issue-items" id="high-bounce-items">
          <!-- List of content with high bounce rate -->
        </div>
      </div>

      <div class="issue-card poor-rating">
        <h4>Poor Ratings</h4>
        <div class="issue-count" id="poor-rating-count">0</div>
        <div class="issue-items" id="poor-rating-items">
          <!-- List of content with poor ratings -->
        </div>
      </div>
    </div>
  </div>
</section>

class FunnelAnalytics {
  constructor() {
    this.funnels = new Map();
    this.dropOffPoints = new Map();
    this.conversionPaths = new Map();
  }

  defineFunnel(funnelId, steps) {
    this.funnels.set(funnelId, {
      id: funnelId,
      steps: steps,
      users: new Map(),
      conversions: 0,
      dropOffAnalysis: new Map()
    });
  }

  trackFunnelStep(funnelId, userId, stepId, additionalData = {}) {
    const funnel = this.funnels.get(funnelId);
    if (!funnel) return;

    if (!funnel.users.has(userId)) {
      funnel.users.set(userId, {
        currentStep: 0,
        stepsCompleted: [],
        startTime: Date.now(),
        lastActivity: Date.now(),
        metadata: additionalData
      });
    }

    const user = funnel.users.get(userId);
    const stepIndex = funnel.steps.findIndex(step => step.id === stepId);

    if (stepIndex > user.currentStep) {
      // Track drop-off from previous steps
      for (let i = user.currentStep; i < stepIndex; i++) {
        this.trackDropOff(funnelId, funnel.steps[i].id, userId, 'skipped');
      }

      user.currentStep = stepIndex;
      user.stepsCompleted.push({
        stepId: stepId,
        timestamp: Date.now(),
        timeSpent: Date.now() - user.lastActivity,
        metadata: additionalData
      });

      user.lastActivity = Date.now();
    }

    // Check for conversion
    if (stepIndex === funnel.steps.length - 1) {
      funnel.conversions++;
      this.trackConversion(funnelId, userId, additionalData);
    }
  }

  analyzeDropOffs(funnelId) {
    const funnel = this.funnels.get(funnelId);
    const analysis = {
      totalUsers: funnel.users.size,
      stepAnalytics: [],
      criticalDropOffs: [],
      recommendations: []
    };

    // Analyze each step
    funnel.steps.forEach((step, index) => {
      const usersAtStep = Array.from(funnel.users.values())
        .filter(user => user.currentStep >= index).length;

      const usersCompletedStep = Array.from(funnel.users.values())
        .filter(user => user.stepsCompleted.some(s => s.stepId === step.id)).length;

      const dropOffRate = 1 - (usersCompletedStep / usersAtStep);

      analysis.stepAnalytics.push({
        stepId: step.id,
        stepName: step.name,
        usersAtStep: usersAtStep,
        usersCompleted: usersCompletedStep,
        dropOffRate: dropOffRate,
        averageTimeSpent: this.calculateAverageTimeAtStep(funnel, step.id)
      });

      // Identify critical drop-offs
      if (dropOffRate > 0.3) {
        analysis.criticalDropOffs.push({
          stepId: step.id,
          dropOffRate: dropOffRate,
          severity: dropOffRate > 0.5 ? 'critical' : 'high',
          possibleReasons: this.identifyDropOffReasons(funnelId, step.id),
          affectedUsers: usersAtStep - usersCompletedStep
        });
      }
    });

    // Generate recommendations
    analysis.recommendations = this.generateFunnelRecommendations(analysis);

    return analysis;
  }

  generateDropOffReport(funnelId, timeRange) {
    const analysis = this.analyzeDropOffs(funnelId);
    const funnel = this.funnels.get(funnelId);

    return {
      funnelId: funnelId,
      period: timeRange,
      overview: {
        totalUsers: analysis.totalUsers,
        overallConversionRate: funnel.conversions / analysis.totalUsers,
        totalDropOffs: analysis.totalUsers - funnel.conversions
      },
      stepAnalysis: analysis.stepAnalytics,
      criticalDropOffs: analysis.criticalDropOffs,
      userSegments: this.analyzeDropOffBySegments(funnelId),
      timeAnalysis: this.analyzeDropOffByTime(funnelId, timeRange),
      recommendations: analysis.recommendations,
      suggestedAtests: this.generateAtestsuggestions(analysis)
    };
  }
}

<section class="funnel-analytics">
  <h2>Conversion Funnel Analysis</h2>

  <!-- Funnel Selection -->
  <div class="funnel-selector">
    <label>Select Funnel:</label>
    <select id="funnel-select">
      <option value="learning-journey">Learning Journey</option>
      <option value="quiz-completion">Quiz Completion</option>
      <option value="content-consumption">Content Consumption</option>
      <option value="purchase-funnel">Premium Purchase</option>
    </select>
  </div>

  <!-- Funnel Visualization -->
  <div class="funnel-visualization">
    <div class="funnel-chart-container">
      <canvas id="funnel-chart"></canvas>
    </div>

    <div class="funnel-steps-details">
      <table class="funnel-steps-table">
        <thead>
          <tr>
            <th>Step</th>
            <th>Users</th>
            <th>Conversion</th>
            <th>Drop-off</th>
            <th>Avg. Time</th>
            <th>Actions</th>
          </tr>
        </thead>
        <tbody id="funnel-steps-tbody">
          <!-- Dynamically populated -->
        </tbody>
      </table>
    </div>
  </div>

  <!-- Drop-off Analysis -->
  <div class="drop-off-analysis">
    <h3>Critical Drop-off Points</h3>
    <div class="drop-off-cards" id="drop-off-cards">
      <!-- Dynamically populated with critical drop-offs -->
    </div>
  </div>

  <!-- User Path Analysis -->
  <div class="user-path-analysis">
    <h3>User Journey Paths</h3>
    <div class="path-controls">
      <select id="path-segment">
        <option value="all">All Users</option>
        <option value="converted">Converted Users</option>
        <option value="dropped">Dropped Users</option>
      </select>
      <select id="path-timeframe">
        <option value="24h">Last 24 Hours</option>
        <option value="7d">Last 7 Days</option>
        <option value="30d">Last 30 Days</option>
      </select>
    </div>

    <div class="path-visualization">
      <div id="user-paths-chart"></div>
    </div>
  </div>
</section>

class ConversionAnalytics {
  constructor() {
    this.conversions = new Map();
    this.attributionModels = new Map();
    this.cohortAnalysis = new Map();
  }

  trackConversion(userId, conversionType, value, metadata = {}) {
    const conversion = {
      userId: userId,
      type: conversionType,
      value: value,
      timestamp: Date.now(),
      metadata: metadata,
      userJourney: this.reconstructUserJourney(userId),
      attribution: this.calculateAttribution(userId, conversionType),
      cohort: this.assignCohort(userId)
    };

    if (!this.conversions.has(conversionType)) {
      this.conversions.set(conversionType, []);
    }

    this.conversions.get(conversionType).push(conversion);
    this.updateConversionMetrics(conversionType, conversion);
  }

  calculateAttribution(userId, conversionType) {
    const userJourney = this.getUserJourney(userId);
    const touchpoints = userJourney.touchpoints;

    const attributionModels = {
      last_click: this.lastClickAttribution(touchpoints),
      first_click: this.firstClickAttribution(touchpoints),
      linear: this.linearAttribution(touchpoints),
      time_decay: this.timeDecayAttribution(touchpoints),
      position_based: this.positionBasedAttribution(touchpoints)
    };

    return attributionModels;
  }

  generateConversionReport(conversionType, timeRange, segmentation = {}) {
    const conversions = this.getConversions(conversionType, timeRange, segmentation);

    return {
      overview: {
        totalConversions: conversions.length,
        conversionValue: conversions.reduce((sum, c) => sum + c.value, 0),
        conversionRate: this.calculateConversionRate(conversionType, timeRange),
        averageOrderValue: this.calculateAOV(conversions)
      },
      trends: this.analyzeConversionTrends(conversions, timeRange),
      attribution: this.analyzeAttribution(conversions),
      segments: this.analyzeConversionSegments(conversions),
      funnels: this.analyzeConversionFunnels(conversions),
      recommendations: this.generateConversionRecommendations(conversions)
    };
  }

  predictConversionProbability(userId, conversionType) {
    const userFeatures = this.extractUserFeatures(userId);
    const historicalData = this.getHistoricalConversionData(conversionType);

    // Simple probability calculation (in production, use ML models)
    const baseProbability = this.calculateBaseProbability(conversionType);
    const userScore = this.calculateUserScore(userFeatures);
    const contextualFactors = this.getContextualFactors(userId);

    return {
      probability: Math.min(baseProbability * userScore * contextualFactors, 1),
      confidence: this.calculateConfidence(userFeatures, historicalData),
      factors: this.getInfluencingFactors(userFeatures),
      recommendations: this.getConversionRecommendations(userId, conversionType)
    };
  }
}

data_collection_points:
  page_interactions:
    - page_views
    - time_on_page
    - scroll_depth
    - click_events
    - form_interactions

  learning_activities:
    - video_watch_time
    - quiz_attempts
    - practice_completions
    - note_taking
    - bookmarking

  user_behavior:
    - search_queries
    - navigation_patterns
    - content_preferences
    - device_usage
    - session_duration