Hướng Dẫn Theo Dõi và Phân Tích Binance Referral 2025

Trong thế giới affiliate marketing cạnh tranh, việc theo dõi và phân tích hiệu suất là chìa khóa để tối ưu hóa thu nhập từ chương trình giới thiệu Binance. Hướng dẫn này cung cấp framework toàn diện để xây dựng hệ thống tracking và analytics chuyên nghiệp.

1. Tổng Quan Tracking & Analytics {#overview}

1.1 Tầm Quan Trọng của Analytics

Tracking và analytics trong affiliate marketing không chỉ là việc thu thập dữ liệu, mà là việc chuyển đổi dữ liệu thành insights có thể hành động để:

Tối ưu hóa ROI: Xác định kênh và chiến lược hiệu quả nhất
Cải thiện conversion: Phân tích customer journey và tối ưu funnel
Dự đoán xu hướng: Sử dụng dữ liệu lịch sử để dự báo
Tự động hóa quyết định: Thiết lập alerts và automated actions

1.2 Analytics Framework Architecture

// analytics-framework.js
class BinanceReferralAnalytics {
  constructor(config) {
    this.config = config;
    this.dataCollectors = new Map();
    this.processors = new Map();
    this.dashboards = new Map();
    this.alerts = new Map();
    
    this.initializeFramework();
  }

  initializeFramework() {
    // Data Collection Layer
    this.setupDataCollectors();
    
    // Processing Layer
    this.setupDataProcessors();
    
    // Visualization Layer
    this.setupDashboards();
    
    // Alert System
    this.setupAlertSystem();
  }

  setupDataCollectors() {
    // Binance API Collector
    this.dataCollectors.set('binance-api', new BinanceAPICollector({
      apiKey: this.config.binance.apiKey,
      secretKey: this.config.binance.secretKey,
      endpoints: [
        '/sapi/v1/broker/subAccount/bnbBurn/status',
        '/sapi/v1/broker/subAccount/depositHist',
        '/sapi/v1/broker/rebate/recentRecord'
      ]
    }));

    // Website Analytics Collector
    this.dataCollectors.set('website', new WebsiteAnalyticsCollector({
      googleAnalytics: this.config.ga.trackingId,
      customEvents: ['referral_click', 'signup_start', 'signup_complete']
    }));

    // Social Media Collector
    this.dataCollectors.set('social', new SocialMediaCollector({
      platforms: ['twitter', 'telegram', 'youtube', 'tiktok'],
      metrics: ['impressions', 'clicks', 'engagement', 'conversions']
    }));
  }
}

1.3 Data Architecture

graph TD
    A[Data Sources] --> B[Collection Layer]
    B --> C[Processing Layer]
    C --> D[Storage Layer]
    D --> E[Analytics Layer]
    E --> F[Visualization Layer]
    E --> G[Alert System]
    
    A1[Binance API] --> B
    A2[Website Analytics] --> B
    A3[Social Media] --> B
    A4[Email Marketing] --> B
    A5[Paid Ads] --> B
    
    C1[Data Cleaning] --> C
    C2[Transformation] --> C
    C3[Enrichment] --> C
    C4[Aggregation] --> C
    
    D1[Time Series DB] --> D
    D2[Relational DB] --> D
    D3[Cache Layer] --> D
    
    F1[Real-time Dashboard] --> F
    F2[Executive Reports] --> F
    F3[Mobile App] --> F

2. KPI và Metrics Quan Trọng {#kpis-metrics}

2.1 Core Performance Metrics

// kpi-definitions.js
const KPI_DEFINITIONS = {
  // Conversion Metrics
  conversion: {
    clickToSignup: {
      formula: 'signups / clicks * 100',
      target: 15, // 15%
      critical: 10, // Below 10% is critical
      description: 'Tỷ lệ chuyển đổi từ click đến đăng ký'
    },
    
    signupToActive: {
      formula: 'active_users / signups * 100',
      target: 60, // 60%
      critical: 40,
      description: 'Tỷ lệ người dùng đăng ký thành active trader'
    },
    
    activeToCommission: {
      formula: 'commission_generating_users / active_users * 100',
      target: 80, // 80%
      critical: 60,
      description: 'Tỷ lệ active user tạo ra commission'
    }
  },

  // Revenue Metrics
  revenue: {
    totalCommission: {
      formula: 'SUM(commission_amount)',
      target: null, // Set based on goals
      description: 'Tổng commission thu được'
    },
    
    averageCommissionPerUser: {
      formula: 'total_commission / active_users',
      target: 50, // $50 per user
      critical: 20,
      description: 'Commission trung bình mỗi user'
    },
    
    monthlyRecurringRevenue: {
      formula: 'monthly_commission_average',
      target: null,
      description: 'Thu nhập hàng tháng ổn định'
    }
  },

  // Engagement Metrics
  engagement: {
    clickThroughRate: {
      formula: 'clicks / impressions * 100',
      target: 3, // 3%
      critical: 1,
      description: 'Tỷ lệ click trên impression'
    },
    
    returnVisitorRate: {
      formula: 'return_visitors / total_visitors * 100',
      target: 40, // 40%
      critical: 20,
      description: 'Tỷ lệ visitor quay lại'
    },
    
    sessionDuration: {
      formula: 'AVG(session_duration)',
      target: 300, // 5 minutes
      critical: 120, // 2 minutes
      description: 'Thời gian session trung bình (giây)'
    }
  }
};

class KPICalculator {
  constructor(dataSource) {
    this.dataSource = dataSource;
    this.cache = new Map();
  }

  async calculateKPI(kpiName, timeRange = '30d') {
    const cacheKey = `${kpiName}_${timeRange}`;
    
    if (this.cache.has(cacheKey)) {
      const cached = this.cache.get(cacheKey);
      if (Date.now() - cached.timestamp < 300000) { // 5 minutes cache
        return cached.value;
      }
    }

    const kpiDef = this.findKPIDefinition(kpiName);
    if (!kpiDef) {
      throw new Error(`KPI definition not found: ${kpiName}`);
    }

    const data = await this.dataSource.getData(timeRange);
    const value = this.evaluateFormula(kpiDef.formula, data);
    
    const result = {
      value,
      target: kpiDef.target,
      critical: kpiDef.critical,
      status: this.getKPIStatus(value, kpiDef),
      trend: await this.calculateTrend(kpiName, timeRange),
      timestamp: Date.now()
    };

    this.cache.set(cacheKey, result);
    return result;
  }

  getKPIStatus(value, definition) {
    if (definition.critical && value < definition.critical) {
      return 'critical';
    }
    if (definition.target && value < definition.target) {
      return 'warning';
    }
    return 'good';
  }

  async calculateTrend(kpiName, timeRange) {
    const currentPeriod = await this.calculateKPI(kpiName, timeRange);
    const previousPeriod = await this.calculateKPI(kpiName, this.getPreviousPeriod(timeRange));
    
    const change = ((currentPeriod.value - previousPeriod.value) / previousPeriod.value) * 100;
    
    return {
      change: change.toFixed(2),
      direction: change > 0 ? 'up' : change < 0 ? 'down' : 'stable',
      previousValue: previousPeriod.value
    };
  }
}

2.2 Advanced Metrics Dashboard

// advanced-metrics.js
class AdvancedMetricsCalculator {
  constructor(dataSource) {
    this.dataSource = dataSource;
  }

  // Customer Lifetime Value
  async calculateCLV(userId = null, segment = null) {
    const query = `
      SELECT 
        user_id,
        SUM(commission_amount) as total_commission,
        COUNT(DISTINCT DATE(created_at)) as active_days,
        DATEDIFF(MAX(created_at), MIN(created_at)) as lifetime_days,
        AVG(commission_amount) as avg_commission_per_transaction
      FROM commissions 
      WHERE 1=1
      ${userId ? `AND user_id = '${userId}'` : ''}
      ${segment ? `AND user_segment = '${segment}'` : ''}
      GROUP BY user_id
    `;

    const results = await this.dataSource.query(query);
    
    return results.map(user => ({
      userId: user.user_id,
      clv: user.total_commission,
      avgDailyValue: user.total_commission / Math.max(user.lifetime_days, 1),
      engagementRate: user.active_days / Math.max(user.lifetime_days, 1),
      avgTransactionValue: user.avg_commission_per_transaction
    }));
  }

  // Cohort Analysis
  async performCohortAnalysis(startDate, endDate) {
    const cohortQuery = `
      WITH user_cohorts AS (
        SELECT 
          user_id,
          DATE_FORMAT(first_signup, '%Y-%m') as cohort_month,
          DATEDIFF(commission_date, first_signup) as period_number
        FROM (
          SELECT 
            u.user_id,
            u.signup_date as first_signup,
            c.created_at as commission_date,
            c.amount as commission_amount
          FROM users u
          LEFT JOIN commissions c ON u.user_id = c.user_id
          WHERE u.signup_date BETWEEN '${startDate}' AND '${endDate}'
        ) base
      )
      SELECT 
        cohort_month,
        period_number,
        COUNT(DISTINCT user_id) as active_users,
        SUM(commission_amount) as total_revenue
      FROM user_cohorts
      WHERE period_number >= 0
      GROUP BY cohort_month, period_number
      ORDER BY cohort_month, period_number
    `;

    const cohortData = await this.dataSource.query(cohortQuery);
    return this.formatCohortData(cohortData);
  }

  // Attribution Analysis
  async analyzeAttribution(timeRange = '30d') {
    const attributionQuery = `
      SELECT 
        traffic_source,
        medium,
        campaign,
        COUNT(DISTINCT user_id) as users,
        COUNT(DISTINCT CASE WHEN commission_amount > 0 THEN user_id END) as converting_users,
        SUM(commission_amount) as total_commission,
        AVG(commission_amount) as avg_commission
      FROM user_sessions us
      LEFT JOIN commissions c ON us.user_id = c.user_id
      WHERE us.session_date >= DATE_SUB(NOW(), INTERVAL ${timeRange})
      GROUP BY traffic_source, medium, campaign
      ORDER BY total_commission DESC
    `;

    const results = await this.dataSource.query(attributionQuery);
    
    return results.map(row => ({
      source: row.traffic_source,
      medium: row.medium,
      campaign: row.campaign,
      users: row.users,
      conversionRate: (row.converting_users / row.users * 100).toFixed(2),
      totalRevenue: row.total_commission,
      revenuePerUser: (row.total_commission / row.users).toFixed(2),
      roi: this.calculateROI(row.campaign, row.total_commission)
    }));
  }
}

3. Dashboard Analytics Setup {#dashboard-setup}

3.1 Real-time Dashboard Architecture

// dashboard-setup.js
class RealTimeDashboard {
  constructor(config) {
    this.config = config;
    this.websocket = null;
    this.charts = new Map();
    this.widgets = new Map();
    this.updateInterval = 30000; // 30 seconds
    
    this.initializeDashboard();
  }

  initializeDashboard() {
    this.setupWebSocket();
    this.createWidgets();
    this.setupAutoRefresh();
    this.bindEventListeners();
  }

  setupWebSocket() {
    this.websocket = new WebSocket(this.config.websocketUrl);
    
    this.websocket.onmessage = (event) => {
      const data = JSON.parse(event.data);
      this.handleRealTimeUpdate(data);
    };

    this.websocket.onclose = () => {
      console.log('WebSocket connection closed, attempting to reconnect...');
      setTimeout(() => this.setupWebSocket(), 5000);
    };
  }

  createWidgets() {
    // Revenue Widget
    this.widgets.set('revenue', new RevenueWidget({
      container: '#revenue-widget',
      metrics: ['total_commission', 'daily_commission', 'monthly_commission'],
      refreshInterval: 60000
    }));

    // Conversion Funnel Widget
    this.widgets.set('funnel', new ConversionFunnelWidget({
      container: '#funnel-widget',
      stages: ['impressions', 'clicks', 'signups', 'active_users', 'commission_users'],
      refreshInterval: 300000 // 5 minutes
    }));

    // Traffic Sources Widget
    this.widgets.set('traffic', new TrafficSourcesWidget({
      container: '#traffic-widget',
      sources: ['organic', 'social', 'paid', 'email', 'direct'],
      refreshInterval: 120000 // 2 minutes
    }));

    // Performance Trends Widget
    this.widgets.set('trends', new PerformanceTrendsWidget({
      container: '#trends-widget',
      metrics: ['ctr', 'conversion_rate', 'avg_commission'],
      timeRange: '7d',
      refreshInterval: 180000 // 3 minutes
    }));
  }

  handleRealTimeUpdate(data) {
    switch (data.type) {
      case 'new_commission':
        this.updateCommissionMetrics(data.payload);
        break;
      case 'new_signup':
        this.updateConversionFunnel(data.payload);
        break;
      case 'traffic_spike':
        this.updateTrafficMetrics(data.payload);
        break;
      default:
        console.log('Unknown update type:', data.type);
    }
  }
}

// Widget Base Class
class DashboardWidget {
  constructor(config) {
    this.config = config;
    this.container = document.querySelector(config.container);
    this.data = null;
    this.chart = null;
    
    this.initialize();
  }

  initialize() {
    this.createHTML();
    this.setupChart();
    this.loadData();
    
    if (this.config.refreshInterval) {
      setInterval(() => this.refresh(), this.config.refreshInterval);
    }
  }

  async loadData() {
    try {
      this.showLoading();
      const response = await fetch(this.getDataEndpoint());
      this.data = await response.json();
      this.updateChart();
      this.hideLoading();
    } catch (error) {
      console.error('Error loading widget data:', error);
      this.showError(error.message);
    }
  }

  createHTML() {
    this.container.innerHTML = `
      <div class="widget-header">
        <h3>${this.config.title}</h3>
        <div class="widget-controls">
          <button class="refresh-btn" onclick="this.refresh()">
            <i class="fas fa-sync-alt"></i>
          </button>
          <button class="fullscreen-btn" onclick="this.toggleFullscreen()">
            <i class="fas fa-expand"></i>
          </button>
        </div>
      </div>
      <div class="widget-content">
        <div class="loading-spinner" style="display: none;">
          <i class="fas fa-spinner fa-spin"></i>
        </div>
        <div class="error-message" style="display: none;"></div>
        <div class="chart-container"></div>
      </div>
    `;
  }
}

// Revenue Widget Implementation
class RevenueWidget extends DashboardWidget {
  setupChart() {
    const ctx = this.container.querySelector('.chart-container');
    
    this.chart = new Chart(ctx, {
      type: 'line',
      data: {
        labels: [],
        datasets: [{
          label: 'Daily Commission',
          data: [],
          borderColor: '#f39c12',
          backgroundColor: 'rgba(243, 156, 18, 0.1)',
          tension: 0.4
        }, {
          label: 'Cumulative Commission',
          data: [],
          borderColor: '#27ae60',
          backgroundColor: 'rgba(39, 174, 96, 0.1)',
          tension: 0.4,
          yAxisID: 'y1'
        }]
      },
      options: {
        responsive: true,
        interaction: {
          mode: 'index',
          intersect: false,
        },
        scales: {
          y: {
            type: 'linear',
            display: true,
            position: 'left',
            title: {
              display: true,
              text: 'Daily Commission ($)'
            }
          },
          y1: {
            type: 'linear',
            display: true,
            position: 'right',
            title: {
              display: true,
              text: 'Cumulative Commission ($)'
            },
            grid: {
              drawOnChartArea: false,
            },
          }
        },
        plugins: {
          tooltip: {
            callbacks: {
              label: function(context) {
                return `${context.dataset.label}: $${context.parsed.y.toFixed(2)}`;
              }
            }
          }
        }
      }
    });
  }

  getDataEndpoint() {
    return `/api/analytics/revenue?metrics=${this.config.metrics.join(',')}&range=30d`;
  }

  updateChart() {
    if (!this.data || !this.chart) return;

    const labels = this.data.map(item => item.date);
    const dailyCommission = this.data.map(item => item.daily_commission);
    const cumulativeCommission = this.data.map(item => item.cumulative_commission);

    this.chart.data.labels = labels;
    this.chart.data.datasets[0].data = dailyCommission;
    this.chart.data.datasets[1].data = cumulativeCommission;
    
    this.chart.update('none');
    
    // Update summary stats
    this.updateSummaryStats();
  }

  updateSummaryStats() {
    const totalCommission = this.data.reduce((sum, item) => sum + item.daily_commission, 0);
    const avgDailyCommission = totalCommission / this.data.length;
    const bestDay = Math.max(...this.data.map(item => item.daily_commission));
    
    const summaryHTML = `
      <div class="revenue-summary">
        <div class="stat-item">
          <span class="stat-label">Total Commission</span>
          <span class="stat-value">$${totalCommission.toFixed(2)}</span>
        </div>
        <div class="stat-item">
          <span class="stat-label">Daily Average</span>
          <span class="stat-value">$${avgDailyCommission.toFixed(2)}</span>
        </div>
        <div class="stat-item">
          <span class="stat-label">Best Day</span>
          <span class="stat-value">$${bestDay.toFixed(2)}</span>
        </div>
      </div>
    `;
    
    // Insert summary before chart
    const chartContainer = this.container.querySelector('.chart-container');
    const existingSummary = this.container.querySelector('.revenue-summary');
    
    if (existingSummary) {
      existingSummary.remove();
    }
    
    chartContainer.insertAdjacentHTML('beforebegin', summaryHTML);
  }
}

3.2 Mobile-Responsive Dashboard

/* dashboard-styles.css */
.dashboard-container {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
  gap: 20px;
  padding: 20px;
  background: #f8f9fa;
  min-height: 100vh;
}

.widget {
  background: white;
  border-radius: 8px;
  box-shadow: 0 2px 10px rgba(0,0,0,0.1);
  overflow: hidden;
  transition: transform 0.2s ease;
}

.widget:hover {
  transform: translateY(-2px);
  box-shadow: 0 4px 20px rgba(0,0,0,0.15);
}

.widget-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 15px 20px;
  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
  color: white;
}

.widget-header h3 {
  margin: 0;
  font-size: 1.1rem;
  font-weight: 600;
}

.widget-controls {
  display: flex;
  gap: 10px;
}

.widget-controls button {
  background: rgba(255,255,255,0.2);
  border: none;
  color: white;
  padding: 8px;
  border-radius: 4px;
  cursor: pointer;
  transition: background 0.2s ease;
}

.widget-controls button:hover {
  background: rgba(255,255,255,0.3);
}

.widget-content {
  padding: 20px;
  position: relative;
}

.loading-spinner {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  font-size: 2rem;
  color: #667eea;
}

.error-message {
  background: #fee;
  color: #c33;
  padding: 10px;
  border-radius: 4px;
  margin-bottom: 15px;
}

.chart-container {
  position: relative;
  height: 300px;
}

.revenue-summary {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
  gap: 15px;
  margin-bottom: 20px;
}

.stat-item {
  text-align: center;
  padding: 15px;
  background: #f8f9fa;
  border-radius: 6px;
}

.stat-label {
  display: block;
  font-size: 0.85rem;
  color: #666;
  margin-bottom: 5px;
}

.stat-value {
  display: block;
  font-size: 1.5rem;
  font-weight: 700;
  color: #333;
}

/* Mobile Responsiveness */
@media (max-width: 768px) {
  .dashboard-container {
    grid-template-columns: 1fr;
    padding: 10px;
    gap: 15px;
  }
  
  .widget-header {
    padding: 12px 15px;
  }
  
  .widget-header h3 {
    font-size: 1rem;
  }
  
  .widget-content {
    padding: 15px;
  }
  
  .chart-container {
    height: 250px;
  }
  
  .revenue-summary {
    grid-template-columns: 1fr;
    gap: 10px;
  }
  
  .stat-item {
    padding: 12px;
  }
}

/* Dark Mode Support */
@media (prefers-color-scheme: dark) {
  .dashboard-container {
    background: #1a1a1a;
  }
  
  .widget {
    background: #2d2d2d;
    color: #e0e0e0;
  }
  
  .stat-item {
    background: #3a3a3a;
  }
  
  .stat-value {
    color: #e0e0e0;
  }
}

4. Conversion Tracking System {#conversion-tracking}

4.1 Multi-Touch Attribution Setup

// conversion-tracking.js
class ConversionTrackingSystem {
  constructor(config) {
    this.config = config;
    this.touchpoints = [];
    this.attributionModel = config.attributionModel || 'linear';
    this.cookieDuration = config.cookieDuration || 30; // days
    
    this.initializeTracking();
  }

  initializeTracking() {
    this.setupEventListeners();
    this.loadExistingTouchpoints();
    this.initializePixels();
  }

  // Track user touchpoints
  trackTouchpoint(data) {
    const touchpoint = {
      id: this.generateTouchpointId(),
      timestamp: Date.now(),
      source: data.source,
      medium: data.medium,
      campaign: data.campaign,
      content: data.content,
      term: data.term,
      referrer: document.referrer,
      landingPage: window.location.href,
      userAgent: navigator.userAgent,
      sessionId: this.getSessionId(),
      userId: this.getUserId()
    };

    this.touchpoints.push(touchpoint);
    this.saveTouchpoints();
    
    // Send to analytics
    this.sendToAnalytics('touchpoint', touchpoint);
    
    return touchpoint;
  }

  // Track conversion events
  trackConversion(conversionData) {
    const conversion = {
      id: this.generateConversionId(),
      timestamp: Date.now(),
      type: conversionData.type, // 'signup', 'first_trade', 'commission'
      value: conversionData.value || 0,
      currency: conversionData.currency || 'USD',
      userId: this.getUserId(),
      sessionId: this.getSessionId(),
      touchpoints: this.getTouchpointsForAttribution()
    };

    // Apply attribution model
    const attributedTouchpoints = this.applyAttributionModel(
      conversion.touchpoints, 
      conversion.value
    );

    conversion.attribution = attributedTouchpoints;
    
    // Save conversion
    this.saveConversion(conversion);
    
    // Send to analytics
    this.sendToAnalytics('conversion', conversion);
    
    // Trigger webhooks
    this.triggerWebhooks(conversion);
    
    return conversion;
  }

  applyAttributionModel(touchpoints, conversionValue) {
    switch (this.attributionModel) {
      case 'first_touch':
        return this.firstTouchAttribution(touchpoints, conversionValue);
      case 'last_touch':
        return this.lastTouchAttribution(touchpoints, conversionValue);
      case 'linear':
        return this.linearAttribution(touchpoints, conversionValue);
      case 'time_decay':
        return this.timeDecayAttribution(touchpoints, conversionValue);
      case 'position_based':
        return this.positionBasedAttribution(touchpoints, conversionValue);
      default:
        return this.linearAttribution(touchpoints, conversionValue);
    }
  }

  linearAttribution(touchpoints, value) {
    if (touchpoints.length === 0) return [];
    
    const valuePerTouchpoint = value / touchpoints.length;
    
    return touchpoints.map(tp => ({
      ...tp,
      attributedValue: valuePerTouchpoint,
      attributionWeight: 1 / touchpoints.length
    }));
  }

  timeDecayAttribution(touchpoints, value) {
    if (touchpoints.length === 0) return [];
    
    const now = Date.now();
    const halfLife = 7 * 24 * 60 * 60 * 1000; // 7 days in milliseconds
    
    // Calculate decay weights
    const weights = touchpoints.map(tp => {
      const age = now - tp.timestamp;
      return Math.pow(0.5, age / halfLife);
    });
    
    const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
    
    return touchpoints.map((tp, index) => ({
      ...tp,
      attributedValue: (weights[index] / totalWeight) * value,
      attributionWeight: weights[index] / totalWeight
    }));
  }

  positionBasedAttribution(touchpoints, value) {
    if (touchpoints.length === 0) return [];
    if (touchpoints.length === 1) {
      return [{
        ...touchpoints[0],
        attributedValue: value,
        attributionWeight: 1
      }];
    }
    
    // 40% to first, 40% to last, 20% distributed among middle
    const firstWeight = 0.4;
    const lastWeight = 0.4;
    const middleWeight = 0.2;
    
    return touchpoints.map((tp, index) => {
      let weight;
      if (index === 0) {
        weight = firstWeight;
      } else if (index === touchpoints.length - 1) {
        weight = lastWeight;
      } else {
        weight = middleWeight / (touchpoints.length - 2);
      }
      
      return {
        ...tp,
        attributedValue: weight * value,
        attributionWeight: weight
      };
    });
  }
}

// Enhanced Event Tracking
class EnhancedEventTracker {
  constructor(trackingSystem) {
    this.trackingSystem = trackingSystem;
    this.setupAdvancedTracking();
  }

  setupAdvancedTracking() {
    // Track scroll depth
    this.trackScrollDepth();
    
    // Track time on page
    this.trackTimeOnPage();
    
    // Track form interactions
    this.trackFormInteractions();
    
    // Track button clicks
    this.trackButtonClicks();
    
    // Track video engagement
    this.trackVideoEngagement();
  }

  trackScrollDepth() {
    let maxScroll = 0;
    const milestones = [25, 50, 75, 90, 100];
    const triggered = new Set();

    window.addEventListener('scroll', () => {
      const scrollPercent = Math.round(
        (window.scrollY / (document.body.scrollHeight - window.innerHeight)) * 100
      );
      
      maxScroll = Math.max(maxScroll, scrollPercent);
      
      milestones.forEach(milestone => {
        if (scrollPercent >= milestone && !triggered.has(milestone)) {
          triggered.add(milestone);
          
          this.trackingSystem.trackEvent({
            category: 'Engagement',
            action: 'Scroll Depth',
            label: `${milestone}%`,
            value: milestone
          });
        }
      });
    });
  }

  trackTimeOnPage() {
    const startTime = Date.now();
    const intervals = [30, 60, 120, 300, 600]; // seconds
    const triggered = new Set();

    setInterval(() => {
      const timeOnPage = Math.floor((Date.now() - startTime) / 1000);
      
      intervals.forEach(interval => {
        if (timeOnPage >= interval && !triggered.has(interval)) {
          triggered.add(interval);
          
          this.trackingSystem.trackEvent({
            category: 'Engagement',
            action: 'Time on Page',
            label: `${interval}s`,
            value: interval
          });
        }
      });
    }, 10000); // Check every 10 seconds
  }

  trackFormInteractions() {
    document.addEventListener('focus', (event) => {
      if (event.target.tagName === 'INPUT' || event.target.tagName === 'TEXTAREA') {
        this.trackingSystem.trackEvent({
          category: 'Form',
          action: 'Field Focus',
          label: event.target.name || event.target.id || 'unknown'
        });
      }
    }, true);

    document.addEventListener('submit', (event) => {
      const form = event.target;
      if (form.tagName === 'FORM') {
        this.trackingSystem.trackEvent({
          category: 'Form',
          action: 'Submit',
          label: form.id || form.className || 'unknown'
        });
      }
    });
  }
}

4.2 Cross-Device Tracking

// cross-device-tracking.js
class CrossDeviceTracker {
  constructor(config) {
    this.config = config;
    this.deviceFingerprint = null;
    this.userIdentifiers = new Map();
    
    this.initializeCrossDeviceTracking();
  }

  initializeCrossDeviceTracking() {
    this.generateDeviceFingerprint();
    this.setupIdentifierCollection();
    this.implementProbabilisticMatching();
  }

  async generateDeviceFingerprint() {
    const fingerprint = {
      userAgent: navigator.userAgent,
      language: navigator.language,
      platform: navigator.platform,
      screenResolution: `${screen.width}x${screen.height}`,
      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
      colorDepth: screen.colorDepth,
      pixelRatio: window.devicePixelRatio,
      touchSupport: 'ontouchstart' in window,
      cookieEnabled: navigator.cookieEnabled,
      doNotTrack: navigator.doNotTrack,
      plugins: Array.from(navigator.plugins).map(p => p.name).sort(),
      fonts: await this.detectFonts(),
      canvas: this.getCanvasFingerprint(),
      webgl: this.getWebGLFingerprint()
    };

    this.deviceFingerprint = this.hashFingerprint(fingerprint);
    return this.deviceFingerprint;
  }

  async detectFonts() {
    const testFonts = [
      'Arial', 'Helvetica', 'Times New Roman', 'Courier New',
      'Verdana', 'Georgia', 'Palatino', 'Garamond',
      'Bookman', 'Comic Sans MS', 'Trebuchet MS', 'Arial Black'
    ];

    const detectedFonts = [];
    const testString = 'mmmmmmmmmmlli';
    const testSize = '72px';
    const baseFonts = ['monospace', 'sans-serif', 'serif'];

    const canvas = document.createElement('canvas');
    const context = canvas.getContext('2d');

    for (const font of testFonts) {
      let detected = false;
      
      for (const baseFont of baseFonts) {
        context.font = `${testSize} ${baseFont}`;
        const baseWidth = context.measureText(testString).width;
        
        context.font = `${testSize} ${font}, ${baseFont}`;
        const testWidth = context.measureText(testString).width;
        
        if (baseWidth !== testWidth) {
          detected = true;
          break;
        }
      }
      
      if (detected) {
        detectedFonts.push(font);
      }
    }

    return detectedFonts.sort();
  }

  getCanvasFingerprint() {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    
    ctx.textBaseline = 'top';
    ctx.font = '14px Arial';
    ctx.fillText('Device fingerprinting canvas', 2, 2);
    
    return canvas.toDataURL();
  }

  setupIdentifierCollection() {
    // Email-based identification
    document.addEventListener('input', (event) => {
      if (event.target.type === 'email' && this.isValidEmail(event.target.value)) {
        this.addIdentifier('email', event.target.value);
      }
    });

    // Phone number identification
    document.addEventListener('input', (event) => {
      if (event.target.type === 'tel' && this.isValidPhone(event.target.value)) {
        this.addIdentifier('phone', event.target.value);
      }
    });

    // Login detection
    document.addEventListener('submit', (event) => {
      const form = event.target;
      if (form.querySelector('input[type="email"]') && form.querySelector('input[type="password"]')) {
        const email = form.querySelector('input[type="email"]').value;
        if (this.isValidEmail(email)) {
          this.addIdentifier('login_email', email);
        }
      }
    });
  }

  addIdentifier(type, value) {
    this.userIdentifiers.set(type, {
      value: this.hashValue(value),
      timestamp: Date.now(),
      deviceFingerprint: this.deviceFingerprint
    });

    // Send to server for cross-device matching
    this.sendIdentifierToServer(type, value);
  }

  async sendIdentifierToServer(type, value) {
    try {
      await fetch('/api/tracking/identifier', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          type,
          hashedValue: this.hashValue(value),
          deviceFingerprint: this.deviceFingerprint,
          timestamp: Date.now(),
          sessionId: this.getSessionId()
        })
      });
    } catch (error) {
      console.error('Failed to send identifier:', error);
    }
  }
}

5. Attribution Modeling {#attribution-modeling}

5.1 Advanced Attribution Models

// attribution-models.js
class AdvancedAttributionModels {
  constructor(touchpointData) {
    this.touchpoints = touchpointData;
    this.models = {
      'data_driven': this.dataDrivenAttribution.bind(this),
      'shapley_value': this.shapleyValueAttribution.bind(this),
      'markov_chain': this.markovChainAttribution.bind(this),
      'algorithmic': this.algorithmicAttribution.bind(this)
    };
  }

  // Data-Driven Attribution using Machine Learning
  async dataDrivenAttribution(conversions) {
    const features = this.extractFeatures(conversions);
    const model = await this.trainAttributionModel(features);
    
    return conversions.map(conversion => {
      const touchpointContributions = model.predict(conversion.touchpoints);
      
      return conversion.touchpoints.map((tp, index) => ({
        ...tp,
        attributedValue: touchpointContributions[index] * conversion.value,
        attributionWeight: touchpointContributions[index],
        confidence: model.getConfidence(conversion.touchpoints, index)
      }));
    });
  }

  extractFeatures(conversions) {
    return conversions.map(conversion => {
      return conversion.touchpoints.map(tp => ({
        // Channel features
        isFirstTouch: tp.position === 0,
        isLastTouch: tp.position === conversion.touchpoints.length - 1,
        channelType: this.categorizeChannel(tp.source),
        
        // Temporal features
        timeSinceFirstTouch: tp.timestamp - conversion.touchpoints[0].timestamp,
        timeToConversion: conversion.timestamp - tp.timestamp,
        dayOfWeek: new Date(tp.timestamp).getDay(),
        hourOfDay: new Date(tp.timestamp).getHours(),
        
        // Engagement features
        sessionDuration: tp.sessionDuration || 0,
        pageViews: tp.pageViews || 1,
        scrollDepth: tp.scrollDepth || 0,
        
        // Context features
        deviceType: tp.deviceType,
        browserType: tp.browserType,
        referrerDomain: this.extractDomain(tp.referrer),
        
        // Campaign features
        campaignType: tp.campaignType,
        adFormat: tp.adFormat,
        targetingType: tp.targetingType
      }));
    });
  }

  // Shapley Value Attribution
  shapleyValueAttribution(touchpoints, conversionValue) {
    const n = touchpoints.length;
    if (n === 0) return [];
    
    const shapleyValues = new Array(n).fill(0);
    
    // Calculate Shapley values for each touchpoint
    for (let i = 0; i < n; i++) {
      for (let subset = 0; subset < (1 << n); subset++) {
        if (subset & (1 << i)) continue; // Skip subsets containing touchpoint i
        
        const subsetSize = this.popcount(subset);
        const weight = this.factorial(subsetSize) * this.factorial(n - subsetSize - 1) / this.factorial(n);
        
        const valueWithout = this.calculateSubsetValue(subset, touchpoints);
        const valueWith = this.calculateSubsetValue(subset | (1 << i), touchpoints);
        
        shapleyValues[i] += weight * (valueWith - valueWithout);
      }
    }
    
    // Normalize to sum to conversion value
    const totalShapley = shapleyValues.reduce((sum, val) => sum + val, 0);
    const normalizedValues = shapleyValues.map(val => (val / totalShapley) * conversionValue);
    
    return touchpoints.map((tp, index) => ({
      ...tp,
      attributedValue: normalizedValues[index],
      attributionWeight: normalizedValues[index] / conversionValue,
      shapleyValue: shapleyValues[index]
    }));
  }

  // Markov Chain Attribution
  markovChainAttribution(conversions) {
    const transitionMatrix = this.buildTransitionMatrix(conversions);
    const removalEffects = this.calculateRemovalEffects(transitionMatrix);
    
    return conversions.map(conversion => {
      return conversion.touchpoints.map(tp => {
        const channel = tp.source;
        const removalEffect = removalEffects[channel] || 0;
        
        return {
          ...tp,
          attributedValue: removalEffect * conversion.value,
          attributionWeight: removalEffect,
          removalEffect: removalEffect
        };
      });
    });
  }

  buildTransitionMatrix(conversions) {
    const transitions = new Map();
    const channels = new Set();
    
    conversions.forEach(conversion => {
      const path = ['START', ...conversion.touchpoints.map(tp => tp.source), 'CONVERSION'];
      
      for (let i = 0; i < path.length - 1; i++) {
        const from = path[i];
        const to = path[i + 1];
        
        channels.add(from);
        channels.add(to);
        
        const key = `${from}->${to}`;
        transitions.set(key, (transitions.get(key) || 0) + 1);
      }
    });
    
    // Convert to probability matrix
    const matrix = {};
    channels.forEach(from => {
      matrix[from] = {};
      let total = 0;
      
      channels.forEach(to => {
        const count = transitions.get(`${from}->${to}`) || 0;
        total += count;
      });
      
      channels.forEach(to => {
        const count = transitions.get(`${from}->${to}`) || 0;
        matrix[from][to] = total > 0 ? count / total : 0;
      });
    });
    
    return matrix;
  }

  calculateRemovalEffects(transitionMatrix) {
    const channels = Object.keys(transitionMatrix).filter(ch => ch !== 'START' && ch !== 'CONVERSION');
    const baseConversionRate = this.calculateConversionProbability(transitionMatrix);
    
    const removalEffects = {};
    
    channels.forEach(channel => {
      const modifiedMatrix = this.removeChannel(transitionMatrix, channel);
      const newConversionRate = this.calculateConversionProbability(modifiedMatrix);
      
      removalEffects[channel] = Math.max(0, baseConversionRate - newConversionRate);
    });
    
    // Normalize removal effects
    const totalEffect = Object.values(removalEffects).reduce((sum, effect) => sum + effect, 0);
    
    if (totalEffect > 0) {
      Object.keys(removalEffects).forEach(channel => {
        removalEffects[channel] = removalEffects[channel] / totalEffect;
      });
    }
    
    return removalEffects;
  }
}

// Attribution Comparison Framework
class AttributionComparison {
  constructor() {
    this.models = new AdvancedAttributionModels();
  }

  async compareModels(conversions, models = ['linear', 'time_decay', 'position_based', 'data_driven']) {
    const results = {};
    
    for (const model of models) {
      const startTime = Date.now();
      const attribution = await this.applyModel(model, conversions);
      const endTime = Date.now();
      
      results[model] = {
        attribution: attribution,
        performance: {
          executionTime: endTime - startTime,
          accuracy: await this.calculateAccuracy(attribution, conversions),
          stability: this.calculateStability(attribution),
          interpretability: this.calculateInterpretability(model)
        },
        channelContributions: this.aggregateChannelContributions(attribution),
        insights: this.generateInsights(attribution, model)
      };
    }
    
    return {
      comparison: results,
      recommendation: this.recommendBestModel(results),
      summary: this.generateComparisonSummary(results)
    };
  }

  async calculateAccuracy(attribution, actualConversions) {
    // Use holdout validation to test model accuracy
    const predictions = attribution.map(attr => 
      attr.reduce((sum, tp) => sum + tp.attributedValue, 0)
    );
    
    const actual = actualConversions.map(conv => conv.value);
    
    // Calculate Mean Absolute Percentage Error (MAPE)
    const mape = predictions.reduce((sum, pred, index) => {
      const actual_val = actual[index];
      if (actual_val === 0) return sum;
      return sum + Math.abs((actual_val - pred) / actual_val);
    }, 0) / predictions.length;
    
    return 1 - mape; // Convert to accuracy score
  }

  calculateStability(attribution) {
    // Measure how consistent the model is across different time periods
    const weeklyAttributions = this.groupByWeek(attribution);
    const channelVariances = {};
    
    Object.keys(weeklyAttributions).forEach(week => {
      const weekData = weeklyAttributions[week];
      const channelContributions = this.aggregateChannelContributions(weekData);
      
      Object.keys(channelContributions).forEach(channel => {
        if (!channelVariances[channel]) {
          channelVariances[channel] = [];
        }
        channelVariances[channel].push(channelContributions[channel]);
      });
    });
    
    // Calculate coefficient of variation for each channel
    const stabilityScores = Object.keys(channelVariances).map(channel => {
      const values = channelVariances[channel];
      const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
      const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
      const stdDev = Math.sqrt(variance);
      
      return mean > 0 ? 1 - (stdDev / mean) : 1; // Higher score = more stable
    });
    
    return stabilityScores.reduce((sum, score) => sum + score, 0) / stabilityScores.length;
  }

  recommendBestModel(results) {
    const weights = {
      accuracy: 0.4,
      stability: 0.3,
      interpretability: 0.2,
      executionTime: 0.1
    };
    
    const scores = {};
    
    Object.keys(results).forEach(model => {
      const perf = results[model].performance;
      
      // Normalize execution time (lower is better)
      const maxTime = Math.max(...Object.values(results).map(r => r.performance.executionTime));
      const normalizedTime = 1 - (perf.executionTime / maxTime);
      
      scores[model] = 
        perf.accuracy * weights.accuracy +
        perf.stability * weights.stability +
        perf.interpretability * weights.interpretability +
        normalizedTime * weights.executionTime;
    });
    
    const bestModel = Object.keys(scores).reduce((a, b) => 
      scores[a] > scores[b] ? a : b
    );
    
    return {
      recommended: bestModel,
      score: scores[bestModel],
      reasoning: this.generateRecommendationReasoning(bestModel, results[bestModel]),
      alternatives: Object.keys(scores)
        .filter(model => model !== bestModel)
        .sort((a, b) => scores[b] - scores[a])
        .slice(0, 2)
    };
  }
}

6. Real-time Monitoring {#real-time-monitoring}

6.1 Live Performance Dashboard

// real-time-monitoring.js
class RealTimeMonitoringSystem {
  constructor(config) {
    this.config = config;
    this.websocket = null;
    this.metrics = new Map();
    this.alerts = new Map();
    this.thresholds = config.thresholds || {};
    
    this.initializeMonitoring();
  }

  initializeMonitoring() {
    this.setupWebSocketConnection();
    this.setupMetricsCollection();
    this.setupAlertSystem();
    this.startPerformanceMonitoring();
  }

  setupWebSocketConnection() {
    this.websocket = new WebSocket(this.config.websocketUrl);
    
    this.websocket.onopen = () => {
      console.log('Real-time monitoring connected');
      this.subscribeToMetrics();
    };

    this.websocket.onmessage = (event) => {
      const data = JSON.parse(event.data);
      this.handleRealTimeData(data);
    };

    this.websocket.onclose = () => {
      console.log('Connection lost, attempting to reconnect...');
      setTimeout(() => this.setupWebSocketConnection(), 5000);
    };

    this.websocket.onerror = (error) => {
      console.error('WebSocket error:', error);
    };
  }

  subscribeToMetrics() {
    const subscriptions = [
      'commission_events',
      'signup_events',
      'click_events',
      'conversion_events',
      'traffic_metrics',
      'performance_metrics'
    ];

    subscriptions.forEach(metric => {
      this.websocket.send(JSON.stringify({
        action: 'subscribe',
        metric: metric,
        filters: this.config.filters || {}
      }));
    });
  }

  handleRealTimeData(data) {
    switch (data.type) {
      case 'commission':
        this.updateCommissionMetrics(data);
        break;
      case 'signup':
        this.updateSignupMetrics(data);
        break;
      case 'traffic':
        this.updateTrafficMetrics(data);
        break;
      case 'performance':
        this.updatePerformanceMetrics(data);
        break;
      default:
        console.log('Unknown data type:', data.type);
    }
    
    // Check for alerts
    this.checkAlertConditions(data);
  }

  updateCommissionMetrics(data) {
    const currentMetrics = this.metrics.get('commission') || {
      total: 0,
      count: 0,
      hourly: [],
      bySource: new Map()
    };

    currentMetrics.total += data.amount;
    currentMetrics.count += 1;
    
    // Update hourly data
    const hour = new Date().getHours();
    if (!currentMetrics.hourly[hour]) {
      currentMetrics.hourly[hour] = { amount: 0, count: 0 };
    }
    currentMetrics.hourly[hour].amount += data.amount;
    currentMetrics.hourly[hour].count += 1;
    
    // Update by source
    const source = data.source || 'unknown';
    const sourceData = currentMetrics.bySource.get(source) || { amount: 0, count: 0 };
    sourceData.amount += data.amount;
    sourceData.count += 1;
    currentMetrics.bySource.set(source, sourceData);
    
    this.metrics.set('commission', currentMetrics);
    
    // Update UI
    this.updateCommissionUI(currentMetrics);
    
    // Emit event for other components
    this.emit('commission_updated', currentMetrics);
  }

  setupAlertSystem() {
    // Performance degradation alert
    this.alerts.set('performance_degradation', {
      condition: (data) => {
        if (data.type === 'performance') {
          return data.conversionRate < this.thresholds.minConversionRate;
        }
        return false;
      },
      action: (data) => {
        this.sendAlert({
          level: 'warning',
          title: 'Conversion Rate Drop',
          message: `Conversion rate dropped to ${data.conversionRate}%`,
          data: data
        });
      },
      cooldown: 300000 // 5 minutes
    });

    // Revenue spike alert
    this.alerts.set('revenue_spike', {
      condition: (data) => {
        if (data.type === 'commission') {
          const hourlyAvg = this.calculateHourlyAverage();
          return data.amount > hourlyAvg * 3; // 3x normal
        }
        return false;
      },
      action: (data) => {
        this.sendAlert({
          level: 'info',
          title: 'Revenue Spike Detected',
          message: `Large commission received: $${data.amount}`,
          data: data
        });
      },
      cooldown: 60000 // 1 minute
    });

    // Traffic anomaly alert
    this.alerts.set('traffic_anomaly', {
      condition: (data) => {
        if (data.type === 'traffic') {
          const expected = this.predictTraffic();
          const deviation = Math.abs(data.volume - expected) / expected;
          return deviation > 0.5; // 50% deviation
        }
        return false;
      },
      action: (data) => {
        this.sendAlert({
          level: 'warning',
          title: 'Traffic Anomaly',
          message: `Unusual traffic pattern detected`,
          data: data
        });
      },
      cooldown: 600000 // 10 minutes
    });
  }

  checkAlertConditions(data) {
    this.alerts.forEach((alert, name) => {
      if (alert.condition(data)) {
        const now = Date.now();
        const lastTriggered = alert.lastTriggered || 0;
        
        if (now - lastTriggered > alert.cooldown) {
          alert.action(data);
          alert.lastTriggered = now;
        }
      }
    });
  }

  sendAlert(alert) {
    // Send to multiple channels
    this.sendToSlack(alert);
    this.sendToEmail(alert);
    this.sendToWebhook(alert);
    this.showUINotification(alert);
  }

  async sendToSlack(alert) {
    if (!this.config.slack?.webhookUrl) return;

    const color = {
      'info': '#36a64f',
      'warning': '#ff9500',
      'critical': '#ff0000'
    }[alert.level] || '#36a64f';

    const payload = {
      attachments: [{
        color: color,
        title: alert.title,
        text: alert.message,
        fields: [
          {
            title: 'Time',
            value: new Date().toISOString(),
            short: true
          },
          {
            title: 'Level',
            value: alert.level.toUpperCase(),
            short: true
          }
        ],
        footer: 'Binance Referral Monitoring',
        ts: Math.floor(Date.now() / 1000)
      }]
    };

    try {
      await fetch(this.config.slack.webhookUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload)
      });
    } catch (error) {
      console.error('Failed to send Slack alert:', error);
    }
  }
}

// Performance Monitoring Component
class PerformanceMonitor {
  constructor() {
    this.metrics = {
      pageLoad: [],
      apiResponse: [],
      conversionRate: [],
      errorRate: []
    };
    
    this.startMonitoring();
  }

  startMonitoring() {
    // Monitor page load times
    this.monitorPageLoad();
    
    // Monitor API response times
    this.monitorAPIResponses();
    
    // Monitor conversion rates
    this.monitorConversions();
    
    // Monitor error rates
    this.monitorErrors();
  }

  monitorPageLoad() {
    window.addEventListener('load', () => {
      const navigation = performance.getEntriesByType('navigation')[0];
      const loadTime = navigation.loadEventEnd - navigation.fetchStart;
      
      this.recordMetric('pageLoad', {
        value: loadTime,
        timestamp: Date.now(),
        page: window.location.pathname
      });
      
      // Check if load time exceeds threshold
      if (loadTime > 3000) { // 3 seconds
        this.triggerAlert('slow_page_load', {
          loadTime: loadTime,
          page: window.location.pathname
        });
      }
    });
  }

  monitorAPIResponses() {
    // Intercept fetch requests
    const originalFetch = window.fetch;
    
    window.fetch = async (...args) => {
      const startTime = Date.now();
      
      try {
        const response = await originalFetch(...args);
        const endTime = Date.now();
        const responseTime = endTime - startTime;
        
        this.recordMetric('apiResponse', {
          value: responseTime,
          timestamp: startTime,
          url: args[0],
          status: response.status,
          success: response.ok
        });
        
        // Check for slow API responses
        if (responseTime > 5000) { // 5 seconds
          this.triggerAlert('slow_api_response', {
            responseTime: responseTime,
            url: args[0],
            status: response.status
          });
        }
        
        return response;
      } catch (error) {
        const endTime = Date.now();
        
        this.recordMetric('apiResponse', {
          value: endTime - startTime,
          timestamp: startTime,
          url: args[0],
          error: error.message,
          success: false
        });
        
        throw error;
      }
    };
  }

  recordMetric(type, data) {
    this.metrics[type].push(data);
    
    // Keep only last 1000 entries
    if (this.metrics[type].length > 1000) {
      this.metrics[type] = this.metrics[type].slice(-1000);
    }
    
    // Send to analytics
    this.sendToAnalytics(type, data);
  }

  getMetricsSummary(type, timeRange = 3600000) { // 1 hour default
    const now = Date.now();
    const cutoff = now - timeRange;
    
    const recentMetrics = this.metrics[type].filter(m => m.timestamp >= cutoff);
    
    if (recentMetrics.length === 0) {
      return null;
    }
    
    const values = recentMetrics.map(m => m.value);
    
    return {
      count: recentMetrics.length,
      average: values.reduce((sum, val) => sum + val, 0) / values.length,
      median: this.calculateMedian(values),
      p95: this.calculatePercentile(values, 95),
      p99: this.calculatePercentile(values, 99),
      min: Math.min(...values),
      max: Math.max(...values)
    };
  }
}

7. Automated Reporting {#automated-reporting}

7.1 Report Generation System

// automated-reporting.js
class AutomatedReportingSystem {
  constructor(config) {
    this.config = config;
    this.reportTemplates = new Map();
    this.scheduledReports = new Map();
    this.dataSource = config.dataSource;
    
    this.initializeReporting();
  }

  initializeReporting() {
    this.setupReportTemplates();
    this.setupScheduler();
    this.setupDeliveryChannels();
  }

  setupReportTemplates() {
    // Daily Performance Report
    this.reportTemplates.set('daily_performance', {
      name: 'Daily Performance Report',
      frequency: 'daily',
      time: '09:00',
      timezone: 'UTC',
      recipients: ['team@company.com'],
      format: 'html',
      sections: [
        'executive_summary',
        'key_metrics',
        'conversion_funnel',
        'traffic_sources',
        'top_performers',
        'alerts_summary'
      ],
      dataQueries: {
        timeRange: '24h',
        compareWith: 'previous_period'
      }
    });

    // Weekly Analytics Report
    this.reportTemplates.set('weekly_analytics', {
      name: 'Weekly Analytics Deep Dive',
      frequency: 'weekly',
      day: 'monday',
      time: '08:00',
      timezone: 'UTC',
      recipients: ['analytics@company.com', 'management@company.com'],
      format: 'pdf',
      sections: [
        'executive_summary',
        'performance_trends',
        'cohort_analysis',
        'attribution_analysis',
        'channel_performance',
        'user_behavior',
        'recommendations'
      ],
      dataQueries: {
        timeRange: '7d',
        compareWith: 'previous_week'
      }
    });

    // Monthly Business Review
    this.reportTemplates.set('monthly_business_review', {
      name: 'Monthly Business Review',
      frequency: 'monthly',
      day: 1,
      time: '10:00',
      timezone: 'UTC',
      recipients: ['executives@company.com'],
      format: 'presentation',
      sections: [
        'executive_summary',
        'revenue_analysis',
        'growth_metrics',
        'market_analysis',
        'competitive_analysis',
        'strategic_recommendations',
        'forecast'
      ],
      dataQueries: {
        timeRange: '30d',
        compareWith: 'previous_month'
      }
    });
  }

  async generateReport(templateName, customParams = {}) {
    const template = this.reportTemplates.get(templateName);
    if (!template) {
      throw new Error(`Report template not found: ${templateName}`);
    }

    console.log(`Generating report: ${template.name}`);
    
    try {
      // Collect data for all sections
      const reportData = await this.collectReportData(template, customParams);
      
      // Generate report content
      const reportContent = await this.buildReportContent(template, reportData);
      
      // Format report
      const formattedReport = await this.formatReport(template, reportContent);
      
      // Deliver report
      await this.deliverReport(template, formattedReport);
      
      console.log(`Report generated and delivered: ${template.name}`);
      
      return {
        success: true,
        reportId: this.generateReportId(),
        template: templateName,
        generatedAt: new Date().toISOString(),
        recipients: template.recipients
      };
      
    } catch (error) {
      console.error(`Failed to generate report ${templateName}:`, error);
      
      // Send error notification
      await this.sendErrorNotification(template, error);
      
      throw error;
    }
  }

  async collectReportData(template, customParams) {
    const queries = { ...template.dataQueries, ...customParams };
    const data = {};

    // Executive Summary Data
    if (template.sections.includes('executive_summary')) {
      data.executiveSummary = await this.getExecutiveSummaryData(queries);
    }

    // Key Metrics Data
    if (template.sections.includes('key_metrics')) {
      data.keyMetrics = await this.getKeyMetricsData(queries);
    }

    // Conversion Funnel Data
    if (template.sections.includes('conversion_funnel')) {
      data.conversionFunnel = await this.getConversionFunnelData(queries);
    }

    // Traffic Sources Data
    if (template.sections.includes('traffic_sources')) {
      data.trafficSources = await this.getTrafficSourcesData(queries);
    }

    // Performance Trends Data
    if (template.sections.includes('performance_trends')) {
      data.performanceTrends = await this.getPerformanceTrendsData(queries);
    }

    // Attribution Analysis Data
    if (template.sections.includes('attribution_analysis')) {
      data.attributionAnalysis = await this.getAttributionAnalysisData(queries);
    }

    return data;
  }

  async getExecutiveSummaryData(queries) {
    const timeRange = queries.timeRange;
    const compareWith = queries.compareWith;

    const [currentPeriod, previousPeriod] = await Promise.all([
      this.dataSource.getMetrics(timeRange),
      this.dataSource.getMetrics(compareWith)
    ]);

    return {
      totalRevenue: {
        current: currentPeriod.totalCommission,
        previous: previousPeriod.totalCommission,
        change: this.calculateChange(currentPeriod.totalCommission, previousPeriod.totalCommission)
      },
      totalSignups: {
        current: currentPeriod.signups,
        previous: previousPeriod.signups,
        change: this.calculateChange(currentPeriod.signups, previousPeriod.signups)
      },
      conversionRate: {
        current: currentPeriod.conversionRate,
        previous: previousPeriod.conversionRate,
        change: this.calculateChange(currentPeriod.conversionRate, previousPeriod.conversionRate)
      },
      avgCommissionPerUser: {
        current: currentPeriod.avgCommissionPerUser,
        previous: previousPeriod.avgCommissionPerUser,
        change: this.calculateChange(currentPeriod.avgCommissionPerUser, previousPeriod.avgCommissionPerUser)
      },
      topInsights: await this.generateTopInsights(currentPeriod, previousPeriod)
    };
  }

  async buildReportContent(template, data) {
    const content = {
      title: template.name,
      generatedAt: new Date().toISOString(),
      timeRange: template.dataQueries.timeRange,
      sections: {}
    };

    for (const sectionName of template.sections) {
      content.sections[sectionName] = await this.buildSection(sectionName, data);
    }

    return content;
  }

  async buildSection(sectionName, data) {
    switch (sectionName) {
      case 'executive_summary':
        return this.buildExecutiveSummarySection(data.executiveSummary);
      
      case 'key_metrics':
        return this.buildKeyMetricsSection(data.keyMetrics);
      
      case 'conversion_funnel':
        return this.buildConversionFunnelSection(data.conversionFunnel);
      
      case 'traffic_sources':
        return this.buildTrafficSourcesSection(data.trafficSources);
      
      case 'performance_trends':
        return this.buildPerformanceTrendsSection(data.performanceTrends);
      
      case 'attribution_analysis':
        return this.buildAttributionAnalysisSection(data.attributionAnalysis);
      
      default:
        return { title: sectionName, content: 'Section not implemented' };
    }
  }

  buildExecutiveSummarySection(data) {
    return {
      title: 'Executive Summary',
      content: {
        overview: this.generateOverviewText(data),
        keyHighlights: [
          `Revenue ${data.totalRevenue.change >= 0 ? 'increased' : 'decreased'} by ${Math.abs(data.totalRevenue.change).toFixed(1)}%`,
          `Signups ${data.totalSignups.change >= 0 ? 'grew' : 'declined'} by ${Math.abs(data.totalSignups.change).toFixed(1)}%`,
          `Conversion rate ${data.conversionRate.change >= 0 ? 'improved' : 'declined'} by ${Math.abs(data.conversionRate.change).toFixed(2)} percentage points`
        ],
        metrics: {
          totalRevenue: data.totalRevenue,
          totalSignups: data.totalSignups,
          conversionRate: data.conversionRate,
          avgCommissionPerUser: data.avgCommissionPerUser
        },
        insights: data.topInsights
      }
    };
  }

  async formatReport(template, content) {
    switch (template.format) {
      case 'html':
        return await this.formatAsHTML(content);
      case 'pdf':
        return await this.formatAsPDF(content);
      case 'presentation':
        return await this.formatAsPresentation(content);
      default:
        return await this.formatAsHTML(content);
    }
  }

  async formatAsHTML(content) {
    const html = `
    <!DOCTYPE html>
    <html>
    <head>
        <title>${content.title}</title>
        <style>
            body { font-family: Arial, sans-serif; margin: 40px; }
            .header { border-bottom: 2px solid #333; padding-bottom: 20px; margin-bottom: 30px; }
            .section { margin-bottom: 40px; }
            .metric { display: inline-block; margin: 10px 20px; text-align: center; }
            .metric-value { font-size: 2em; font-weight: bold; color: #333; }
            .metric-label { font-size: 0.9em; color: #666; }
            .change-positive { color: #27ae60; }
            .change-negative { color: #e74c3c; }
            .chart-placeholder { background: #f8f9fa; height: 300px; display: flex; align-items: center; justify-content: center; margin: 20px 0; }
        </style>
    </head>
    <body>
        <div class="header">
            <h1>${content.title}</h1>
            <p>Generated on: ${new Date(content.generatedAt).toLocaleString()}</p>
            <p>Time Range: ${content.timeRange}</p>
        </div>
        
        ${Object.entries(content.sections).map(([name, section]) => 
          this.renderHTMLSection(name, section)
        ).join('')}
    </body>
    </html>
    `;

    return {
      format: 'html',
      content: html,
      filename: `${content.title.replace(/\s+/g, '_')}_${Date.now()}.html`
    };
  }

  renderHTMLSection(name, section) {
    switch (name) {
      case 'executive_summary':
        return `
        <div class="section">
            <h2>${section.title}</h2>
            <p>${section.content.overview}</p>
            
            <h3>Key Highlights</h3>
            <ul>
                ${section.content.keyHighlights.map(highlight => `<li>${highlight}</li>`).join('')}
            </ul>
            
            <h3>Key Metrics</h3>
            <div class="metrics-grid">
                ${Object.entries(section.content.metrics).map(([key, metric]) => `
                    <div class="metric">
                        <div class="metric-value">${this.formatMetricValue(key, metric.current)}</div>
                        <div class="metric-label">${this.formatMetricLabel(key)}</div>
                        <div class="metric-change ${metric.change >= 0 ? 'change-positive' : 'change-negative'}">
                            ${metric.change >= 0 ? '↑' : '↓'} ${Math.abs(metric.change).toFixed(1)}%
                        </div>
                    </div>
                `).join('')}
            </div>
        </div>
        `;
      
      default:
        return `
        <div class="section">
            <h2>${section.title}</h2>
            <div class="chart-placeholder">Chart for ${section.title}</div>
        </div>
        `;
    }
  }
}

8. Predictive Analytics {#predictive-analytics}

8.1 Revenue Forecasting

# predictive-analytics.py
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')

class PredictiveAnalytics:
    def __init__(self, data_source):
        self.data_source = data_source
        self.models = {}
        self.scalers = {}
        self.feature_importance = {}
        
    def prepare_features(self, df, target_column='commission'):
        """Chuẩn bị features cho mô hình dự đoán"""
        
        # Time-based features
        df['hour'] = df['timestamp'].dt.hour
        df['day_of_week'] = df['timestamp'].dt.dayofweek
        df['day_of_month'] = df['timestamp'].dt.day
        df['month'] = df['timestamp'].dt.month
        df['quarter'] = df['timestamp'].dt.quarter
        df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)
        
        # Lag features
        for lag in [1, 7, 30]:
            df[f'{target_column}_lag_{lag}'] = df[target_column].shift(lag)
        
        # Rolling statistics
        for window in [7, 14, 30]:
            df[f'{target_column}_rolling_mean_{window}'] = df[target_column].rolling(window=window).mean()
            df[f'{target_column}_rolling_std_{window}'] = df[target_column].rolling(window=window).std()
        
        # Trend features
        df[f'{target_column}_trend_7d'] = df[target_column].rolling(window=7).apply(
            lambda x: np.polyfit(range(len(x)), x, 1)[0] if len(x) == 7 else 0
        )
        
        # Seasonal decomposition features
        df = self.add_seasonal_features(df, target_column)
        
        # External factors (market data, events, etc.)
        df = self.add_external_features(df)
        
        return df
    
    def add_seasonal_features(self, df, target_column):
        """Thêm features mùa vụ"""
        
        # Fourier features for seasonality
        for period in [7, 30, 365]:  # Weekly, monthly, yearly
            df[f'sin_{period}'] = np.sin(2 * np.pi * df.index / period)
            df[f'cos_{period}'] = np.cos(2 * np.pi * df.index / period)
        
        # Holiday effects
        df['is_holiday'] = self.identify_holidays(df['timestamp'])
        df['days_to_holiday'] = self.calculate_days_to_holiday(df['timestamp'])
        df['days_from_holiday'] = self.calculate_days_from_holiday(df['timestamp'])
        
        return df
    
    def add_external_features(self, df):
        """Thêm features từ yếu tố bên ngoài"""
        
        # Crypto market features
        df['btc_price'] = self.get_btc_price(df['timestamp'])
        df['market_volatility'] = self.calculate_market_volatility(df['timestamp'])
        df['trading_volume'] = self.get_trading_volume(df['timestamp'])
        
        # Economic indicators
        df['vix_index'] = self.get_vix_data(df['timestamp'])
        df['usd_strength'] = self.get_usd_index(df['timestamp'])
        
        # Social sentiment
        df['social_sentiment'] = self.get_social_sentiment(df['timestamp'])
        df['news_sentiment'] = self.get_news_sentiment(df['timestamp'])
        
        return df
    
    def train_ensemble_model(self, df, target_column='commission', test_size=0.2):
        """Huấn luyện mô hình ensemble"""
        
        # Prepare data
        df_prepared = self.prepare_features(df, target_column)
        df_prepared = df_prepared.dropna()
        
        # Split features and target
        feature_columns = [col for col in df_prepared.columns 
                          if col not in ['timestamp', target_column]]
        X = df_prepared[feature_columns]
        y = df_prepared[target_column]
        
        # Train-test split
        split_idx = int(len(X) * (1 - test_size))
        X_train, X_test = X[:split_idx], X[split_idx:]
        y_train, y_test = y[:split_idx], y[split_idx:]
        
        # Scale features
        scaler = StandardScaler()
        X_train_scaled = scaler.fit_transform(X_train)
        X_test_scaled = scaler.transform(X_test)
        
        # Train multiple models
        models = {
            'random_forest': RandomForestRegressor(
                n_estimators=100, 
                max_depth=10, 
                random_state=42
            ),
            'gradient_boosting': GradientBoostingRegressor(
                n_estimators=100, 
                max_depth=6, 
                random_state=42
            ),
            'linear_regression': LinearRegression()
        }
        
        model_predictions = {}
        model_scores = {}
        
        for name, model in models.items():
            if name == 'linear_regression':
                model.fit(X_train_scaled, y_train)
                predictions = model.predict(X_test_scaled)
            else:
                model.fit(X_train, y_train)
                predictions = model.predict(X_test)
            
            model_predictions[name] = predictions
            model_scores[name] = {
                'mae': mean_absolute_error(y_test, predictions),
                'rmse': np.sqrt(mean_squared_error(y_test, predictions)),
                'mape': np.mean(np.abs((y_test - predictions) / y_test)) * 100
            }
            
            self.models[name] = model
        
        # Ensemble prediction (weighted average)
        weights = self.calculate_model_weights(model_scores)
        ensemble_prediction = np.average(
            list(model_predictions.values()), 
            axis=0, 
            weights=list(weights.values())
        )
        
        ensemble_score = {
            'mae': mean_absolute_error(y_test, ensemble_prediction),
            'rmse': np.sqrt(mean_squared_error(y_test, ensemble_prediction)),
            'mape': np.mean(np.abs((y_test - ensemble_prediction) / y_test)) * 100
        }
        
        self.scalers[target_column] = scaler
        
        return {
            'individual_scores': model_scores,
            'ensemble_score': ensemble_score,
            'feature_importance': self.get_feature_importance(X.columns),
            'test_predictions': {
                'actual': y_test.values,
                'ensemble': ensemble_prediction,
                **model_predictions
            }
        }
    
    def forecast_revenue(self, days_ahead=30, confidence_interval=0.95):
        """Dự đoán doanh thu trong tương lai"""
        
        # Get recent data for forecasting
        recent_data = self.data_source.get_recent_data(days=90)
        
        forecasts = []
        confidence_bounds = []
        
        for day in range(1, days_ahead + 1):
            # Prepare features for the forecast day
            forecast_date = datetime.now() + timedelta(days=day)
            features = self.prepare_forecast_features(recent_data, forecast_date)
            
            # Get predictions from all models
            predictions = []
            for name, model in self.models.items():
                if name == 'linear_regression':
                    features_scaled = self.scalers['commission'].transform([features])
                    pred = model.predict(features_scaled)[0]
                else:
                    pred = model.predict([features])[0]
                predictions.append(pred)
            
            # Ensemble prediction
            weights = list(self.calculate_model_weights().values())
            ensemble_pred = np.average(predictions, weights=weights)
            
            # Calculate confidence interval
            pred_std = np.std(predictions)
            z_score = 1.96 if confidence_interval == 0.95 else 2.576  # 99%
            margin = z_score * pred_std
            
            forecasts.append(ensemble_pred)
            confidence_bounds.append({
                'lower': ensemble_pred - margin,
                'upper': ensemble_pred + margin
            })
        
        return {
            'forecasts': forecasts,
            'confidence_bounds': confidence_bounds,
            'dates': [datetime.now() + timedelta(days=i) for i in range(1, days_ahead + 1)]
        }
    
    def detect_anomalies(self, df, target_column='commission', threshold=2.5):
        """Phát hiện bất thường trong dữ liệu"""
        
        # Statistical anomaly detection
        rolling_mean = df[target_column].rolling(window=7).mean()
        rolling_std = df[target_column].rolling(window=7).std()
        
        z_scores = np.abs((df[target_column] - rolling_mean) / rolling_std)
        statistical_anomalies = z_scores > threshold
        
        # Model-based anomaly detection
        df_prepared = self.prepare_features(df, target_column)
        df_prepared = df_prepared.dropna()
        
        feature_columns = [col for col in df_prepared.columns 
                          if col not in ['timestamp', target_column]]
        X = df_prepared[feature_columns]
        y = df_prepared[target_column]
        
        # Use trained model to predict and find large residuals
        if 'random_forest' in self.models:
            predictions = self.models['random_forest'].predict(X)
            residuals = np.abs(y - predictions)
            residual_threshold = np.percentile(residuals, 95)  # Top 5% as anomalies
            model_anomalies = residuals > residual_threshold
        else:
            model_anomalies = np.zeros(len(y), dtype=bool)
        
        # Combine anomaly detection methods
        combined_anomalies = statistical_anomalies | model_anomalies
        
        anomaly_details = []
        for idx in np.where(combined_anomalies)[0]:
            anomaly_details.append({
                'timestamp': df.iloc[idx]['timestamp'],
                'value': df.iloc[idx][target_column],
                'z_score': z_scores.iloc[idx] if idx < len(z_scores) else None,
                'residual': residuals[idx] if idx < len(residuals) else None,
                'type': 'statistical' if statistical_anomalies.iloc[idx] else 'model-based'
            })
        
        return {
            'anomaly_indices': np.where(combined_anomalies)[0],
            'anomaly_details': anomaly_details,
            'total_anomalies': len(anomaly_details),
            'anomaly_rate': len(anomaly_details) / len(df) * 100
        }
    
    def generate_insights(self, forecast_results, anomaly_results):
        """Tạo insights từ kết quả phân tích"""
        
        insights = []
        
        # Revenue trend insights
        forecasts = forecast_results['forecasts']
        if len(forecasts) >= 7:
            week1_avg = np.mean(forecasts[:7])
            week2_avg = np.mean(forecasts[7:14]) if len(forecasts) >= 14 else week1_avg
            
            if week2_avg > week1_avg * 1.1:
                insights.append({
                    'type': 'positive_trend',
                    'message': f'Dự kiến doanh thu sẽ tăng {((week2_avg/week1_avg - 1) * 100):.1f}% trong tuần tới',
                    'confidence': 'high'
                })
            elif week2_avg < week1_avg * 0.9:
                insights.append({
                    'type': 'negative_trend',
                    'message': f'Dự kiến doanh thu sẽ giảm {((1 - week2_avg/week1_avg) * 100):.1f}% trong tuần tới',
                    'confidence': 'medium'
                })
        
        # Seasonality insights
        feature_importance = self.feature_importance
        if 'day_of_week' in feature_importance and feature_importance['day_of_week'] > 0.1:
            insights.append({
                'type': 'seasonality',
                'message': 'Doanh thu có xu hướng theo ngày trong tuần rõ rệt',
                'confidence': 'high'
            })
        
        # Anomaly insights
        if anomaly_results['anomaly_rate'] > 5:
            insights.append({
                'type': 'high_volatility',
                'message': f'Tỷ lệ bất thường cao ({anomaly_results["anomaly_rate"]:.1f}%), cần theo dõi chặt chẽ',
                'confidence': 'high'
            })
        
        # External factor insights
        if 'btc_price' in feature_importance and feature_importance['btc_price'] > 0.15:
            insights.append({
                'type': 'market_correlation',
                'message': 'Doanh thu có tương quan mạnh với giá Bitcoin',
                'confidence': 'high'
            })
        
        return insights

9. Troubleshooting Guide {#troubleshooting}

9.1 Common Issues and Solutions

Tracking Implementation Issues

Vấn đề: Referral links không được track

// Debugging referral tracking
function debugReferralTracking() {
  // Check if tracking code is loaded
  if (typeof window.binanceReferralTracker === 'undefined') {
    console.error('Referral tracker not loaded');
    return false;
  }
  
  // Check URL parameters
  const urlParams = new URLSearchParams(window.location.search);
  const refId = urlParams.get('ref');
  
  if (!refId) {
    console.warn('No referral ID found in URL');
  } else {
    console.log('Referral ID detected:', refId);
  }
  
  // Check cookie storage
  const storedRef = localStorage.getItem('binance_ref_id');
  console.log('Stored referral ID:', storedRef);
  
  // Check API connectivity
  fetch('/api/referral/test')
    .then(response => response.json())
    .then(data => console.log('API test result:', data))
    .catch(error => console.error('API test failed:', error));
  
  return true;
}

// Auto-run debug on page load
window.addEventListener('load', debugReferralTracking);

Giải pháp:

Kiểm tra tracking script được load đúng cách
Xác minh URL parameters được truyền chính xác
Đảm bảo cookies/localStorage hoạt động
Test API endpoints

Data Discrepancy Issues

Vấn đề: Số liệu không khớp giữa các nguồn

# Data validation and reconciliation
class DataValidator:
    def __init__(self, sources):
        self.sources = sources
        
    def validate_data_consistency(self, date_range):
        """Kiểm tra tính nhất quán của dữ liệu"""
        
        results = {}
        
        for source_name, source in self.sources.items():
            try:
                data = source.get_data(date_range)
                results[source_name] = {
                    'total_clicks': data['clicks'].sum(),
                    'total_signups': data['signups'].sum(),
                    'total_commission': data['commission'].sum(),
                    'conversion_rate': data['signups'].sum() / data['clicks'].sum() * 100,
                    'data_points': len(data)
                }
            except Exception as e:
                results[source_name] = {'error': str(e)}
        
        # Compare results
        discrepancies = self.find_discrepancies(results)
        
        return {
            'results': results,
            'discrepancies': discrepancies,
            'recommendations': self.generate_recommendations(discrepancies)
        }
    
    def find_discrepancies(self, results, threshold=0.05):
        """Tìm sự khác biệt giữa các nguồn dữ liệu"""
        
        discrepancies = []
        sources = list(results.keys())
        
        for i in range(len(sources)):
            for j in range(i + 1, len(sources)):
                source1, source2 = sources[i], sources[j]
                
                if 'error' in results[source1] or 'error' in results[source2]:
                    continue
                
                for metric in ['total_clicks', 'total_signups', 'total_commission']:
                    val1 = results[source1][metric]
                    val2 = results[source2][metric]
                    
                    if val1 > 0 and val2 > 0:
                        diff_pct = abs(val1 - val2) / max(val1, val2)
                        
                        if diff_pct > threshold:
                            discrepancies.append({
                                'metric': metric,
                                'source1': source1,
                                'source2': source2,
                                'value1': val1,
                                'value2': val2,
                                'difference_pct': diff_pct * 100
                            })
        
        return discrepancies

Performance Issues

Vấn đề: Dashboard load chậm

// Performance optimization
class PerformanceOptimizer {
  constructor() {
    this.cache = new Map();
    this.requestQueue = [];
    this.isProcessing = false;
  }
  
  // Implement request batching
  async batchRequests(requests, batchSize = 5) {
    const results = [];
    
    for (let i = 0; i < requests.length; i += batchSize) {
      const batch = requests.slice(i, i + batchSize);
      const batchPromises = batch.map(req => this.makeRequest(req));
      
      try {
        const batchResults = await Promise.all(batchPromises);
        results.push(...batchResults);
      } catch (error) {
        console.error('Batch request failed:', error);
        // Handle partial failures
        const individualResults = await Promise.allSettled(batchPromises);
        results.push(...individualResults.map(r => 
          r.status === 'fulfilled' ? r.value : { error: r.reason }
        ));
      }
      
      // Add delay between batches to avoid rate limiting
      if (i + batchSize < requests.length) {
        await this.delay(100);
      }
    }
    
    return results;
  }
  
  // Implement intelligent caching
  async getCachedData(key, fetchFunction, ttl = 300000) { // 5 minutes default
    const cached = this.cache.get(key);
    
    if (cached && Date.now() - cached.timestamp < ttl) {
      return cached.data;
    }
    
    try {
      const data = await fetchFunction();
      this.cache.set(key, {
        data: data,
        timestamp: Date.now()
      });
      return data;
    } catch (error) {
      // Return stale data if available
      if (cached) {
        console.warn('Using stale data due to fetch error:', error);
        return cached.data;
      }
      throw error;
    }
  }
  
  // Implement progressive loading
  async loadDashboardData() {
    const loadingSteps = [
      { name: 'summary', priority: 1, component: 'SummaryCards' },
      { name: 'charts', priority: 2, component: 'ChartsSection' },
      { name: 'tables', priority: 3, component: 'DataTables' },
      { name: 'details', priority: 4, component: 'DetailedAnalytics' }
    ];
    
    // Load high-priority data first
    for (const step of loadingSteps) {
      try {
        const data = await this.getCachedData(
          `dashboard_${step.name}`,
          () => this.fetchStepData(step.name)
        );
        
        // Update UI immediately
        this.updateComponent(step.component, data);
        
      } catch (error) {
        console.error(`Failed to load ${step.name}:`, error);
        this.showErrorState(step.component, error);
      }
    }
  }
}

9.2 API Integration Issues

Vấn đề: Rate limiting và timeout

// Robust API client with retry logic
class RobustAPIClient {
  constructor(config) {
    this.baseURL = config.baseURL;
    this.apiKey = config.apiKey;
    this.maxRetries = config.maxRetries || 3;
    this.retryDelay = config.retryDelay || 1000;
    this.timeout = config.timeout || 30000;
  }
  
  async makeRequest(endpoint, options = {}) {
    const url = `${this.baseURL}${endpoint}`;
    const requestOptions = {
      timeout: this.timeout,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
        ...options.headers
      },
      ...options
    };
    
    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await this.fetchWithTimeout(url, requestOptions);
        
        if (response.ok) {
          return await response.json();
        }
        
        // Handle specific HTTP errors
        if (response.status === 429) {
          // Rate limited - exponential backoff
          const delay = this.retryDelay * Math.pow(2, attempt - 1);
          console.warn(`Rate limited, retrying in ${delay}ms...`);
          await this.delay(delay);
          continue;
        }
        
        if (response.status >= 500) {
          // Server error - retry
          console.warn(`Server error ${response.status}, attempt ${attempt}/${this.maxRetries}`);
          if (attempt < this.maxRetries) {
            await this.delay(this.retryDelay * attempt);
            continue;
          }
        }
        
        // Client error - don't retry
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        
      } catch (error) {
        if (attempt === this.maxRetries) {
          throw error;
        }
        
        console.warn(`Request failed, attempt ${attempt}/${this.maxRetries}:`, error.message);
        await this.delay(this.retryDelay * attempt);
      }
    }
  }
  
  async fetchWithTimeout(url, options) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
    
    try {
      const response = await fetch(url, {
        ...options,
        signal: controller.signal
      });
      return response;
    } finally {
      clearTimeout(timeoutId);
    }
  }
  
  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

10. Kết luận {#conclusion}

Tóm tắt các yếu tố thành công

Hệ thống tracking và analytics cho Binance referral thành công cần có:

Tracking chính xác và toàn diện
- Multi-device và cross-platform tracking
- Real-time data collection
- Attribution modeling chính xác
Analytics sâu sắc và actionable
- KPI tracking chi tiết
- Predictive analytics
- Automated insights generation
Monitoring và alerting proactive
- Real-time performance monitoring
- Anomaly detection
- Multi-channel alerting
Reporting tự động và customizable
- Scheduled report generation
- Multiple format support
- Stakeholder-specific content

Lộ trình phát triển

Phase 1: Foundation (Tháng 1-2)

Implement basic tracking system
Set up core analytics dashboard
Establish data pipeline

Phase 2: Enhancement (Tháng 3-4)

Add advanced attribution modeling
Implement predictive analytics
Set up automated reporting

Phase 3: Optimization (Tháng 5-6)

Performance optimization
Advanced anomaly detection
Machine learning integration

Phase 4: Scale (Tháng 7+)

Multi-region deployment
Advanced AI/ML features
Enterprise-grade monitoring

Tài nguyên hữu ích

Bài viết liên quan:

Cập nhật lần cuối: Tháng 1, 2025

Phân Tích & Theo Dõi Hiệu Suất Mã Giới Thiệu Binance: Dashboard 2025