Search Analytics and Monitoring Guide

// Add to documentation.html after the search functionality
function trackSearchEvent(query, resultCount, searchTime) {
  if (typeof gtag !== 'undefined') {
    gtag('event', 'search', {
      search_term: query,
      search_results: resultCount,
      search_time_ms: searchTime,
      page_title: document.title,
      page_location: window.location.href
    });
  }
}

// Add to performSearch function
function performSearch(query) {
  const startTime = performance.now();
  
  // ... existing search logic ...
  
  const endTime = performance.now();
  const searchTime = Math.round(endTime - startTime);
  
  // Track the search
  trackSearchEvent(query, results.length, searchTime);
}

// For other analytics platforms (Mixpanel, Adobe Analytics, etc.)
function trackCustomAnalytics(event, data) {
  // Mixpanel example
  if (typeof mixpanel !== 'undefined') {
    mixpanel.track(event, data);
  }
  
  // Adobe Analytics example
  if (typeof s !== 'undefined') {
    s.linkTrackVars = 'events,eVar1,eVar2';
    s.events = 'event1';
    s.eVar1 = data.search_term;
    s.eVar2 = data.search_results;
    s.tl(true, 'o', 'Documentation Search');
  }
  
  // Custom endpoint
  fetch('/api/analytics', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ event, data })
  }).catch(() => {}); // Silent fail
}

function trackSearchQuality(query, results, userAction) {
  const metrics = {
    query: query,
    total_results: results.length,
    has_results: results.length > 0,
    query_length: query.length,
    query_words: query.split(' ').length,
    timestamp: new Date().toISOString(),
    user_action: userAction, // 'clicked', 'refined', 'abandoned'
    session_id: getSessionId()
  };
  
  // Track different quality indicators
  if (results.length === 0) {
    trackCustomAnalytics('search_no_results', metrics);
  } else if (results.length === 1) {
    trackCustomAnalytics('search_single_result', metrics);
  } else {
    trackCustomAnalytics('search_multiple_results', metrics);
  }
}

// Track which search results users click
function trackResultClick(result, position, query) {
  const clickData = {
    search_term: query,
    result_title: result.title,
    result_url: result.url,
    result_position: position,
    result_category: result.category,
    click_timestamp: new Date().toISOString()
  };
  
  trackCustomAnalytics('search_result_click', clickData);
}

// Add click tracking to search results
function renderSearchResults(results, query) {
  return results.map((result, index) => `
    <div class="docs-search-item" 
         onclick="handleResultClick('${result.url}', ${index}, '${query}', ${JSON.stringify(result).replace(/'/g, '\\'')}')">
      <!-- result content -->
    </div>
  `).join('');
}

function handleResultClick(url, position, query, result) {
  trackResultClick(result, position, query);
  window.location.href = url;
}

class SearchPerformanceMonitor {
  constructor() {
    this.metrics = {
      searchTimes: [],
      loadTimes: [],
      errorCount: 0,
      totalSearches: 0
    };
  }
  
  recordSearchTime(duration) {
    this.metrics.searchTimes.push(duration);
    this.metrics.totalSearches++;
    
    // Keep only last 100 measurements
    if (this.metrics.searchTimes.length > 100) {
      this.metrics.searchTimes.shift();
    }
    
    // Alert if performance degrades
    if (duration > 100) { // ms
      console.warn(`Slow search detected: ${duration}ms`);
      this.trackPerformanceIssue('slow_search', duration);
    }
  }
  
  recordLoadTime(duration) {
    this.metrics.loadTimes.push(duration);
    
    if (duration > 5000) { // 5 seconds
      console.warn(`Slow search index load: ${duration}ms`);
      this.trackPerformanceIssue('slow_load', duration);
    }
  }
  
  recordError(error) {
    this.metrics.errorCount++;
    console.error('Search error:', error);
    this.trackPerformanceIssue('search_error', error.message);
  }
  
  getAverageSearchTime() {
    const times = this.metrics.searchTimes;
    return times.length > 0 ? times.reduce((a, b) => a + b, 0) / times.length : 0;
  }
  
  trackPerformanceIssue(type, details) {
    trackCustomAnalytics('search_performance_issue', {
      issue_type: type,
      details: details,
      avg_search_time: this.getAverageSearchTime(),
      total_searches: this.metrics.totalSearches,
      error_rate: this.metrics.errorCount / this.metrics.totalSearches
    });
  }
}

const performanceMonitor = new SearchPerformanceMonitor();

// Monitor real user search experience
function initializeRUM() {
  // Track Core Web Vitals impact
  if ('PerformanceObserver' in window) {
    const observer = new PerformanceObserver((list) => {
      list.getEntries().forEach((entry) => {
        if (entry.entryType === 'navigation') {
          trackCustomAnalytics('page_performance', {
            load_time: entry.loadEventEnd - entry.loadEventStart,
            dom_content_loaded: entry.domContentLoadedEventEnd - entry.domContentLoadedEventStart,
            has_search: document.getElementById('search-input') !== null
          });
        }
      });
    });
    observer.observe({ entryTypes: ['navigation'] });
  }
  
  // Track search-specific timing
  window.addEventListener('load', () => {
    const searchLoadStart = performance.now();
    
    // Measure search index load time
    fetch('./search.json')
      .then(() => {
        const searchLoadEnd = performance.now();
        performanceMonitor.recordLoadTime(searchLoadEnd - searchLoadStart);
      })
      .catch((error) => {
        performanceMonitor.recordError(error);
      });
  });
}

// Catch and report search-related errors
window.addEventListener('error', (event) => {
  if (event.filename && event.filename.includes('search')) {
    trackCustomAnalytics('search_javascript_error', {
      message: event.message,
      filename: event.filename,
      line: event.lineno,
      column: event.colno,
      stack: event.error ? event.error.stack : null
    });
  }
});

// Promise rejection handling
window.addEventListener('unhandledrejection', (event) => {
  if (event.reason && event.reason.toString().includes('search')) {
    trackCustomAnalytics('search_promise_rejection', {
      reason: event.reason.toString(),
      stack: event.reason.stack || null
    });
  }
});

function monitorNetworkErrors() {
  const originalFetch = window.fetch;
  
  window.fetch = function(...args) {
    return originalFetch.apply(this, args)
      .then(response => {
        // Monitor search.json requests specifically
        if (args[0].includes('search.json')) {
          if (!response.ok) {
            trackCustomAnalytics('search_network_error', {
              status: response.status,
              statusText: response.statusText,
              url: args[0]
            });
          }
        }
        return response;
      })
      .catch(error => {
        if (args[0].includes('search.json')) {
          trackCustomAnalytics('search_fetch_error', {
            error: error.message,
            url: args[0]
          });
        }
        throw error;
      });
  };
}

class LocalAnalyticsStorage {
  constructor() {
    this.storageKey = 'docs_search_analytics';
  }
  
  store(event) {
    const existing = this.getAll();
    existing.push({
      ...event,
      id: this.generateId(),
      stored_at: new Date().toISOString()
    });
    
    // Keep only last 1000 events
    if (existing.length > 1000) {
      existing.splice(0, existing.length - 1000);
    }
    
    localStorage.setItem(this.storageKey, JSON.stringify(existing));
  }
  
  getAll() {
    try {
      return JSON.parse(localStorage.getItem(this.storageKey) || '[]');
    } catch {
      return [];
    }
  }
  
  generateId() {
    return Date.now().toString(36) + Math.random().toString(36).substr(2);
  }
}

class RemoteAnalyticsService {
  constructor(endpoint, apiKey) {
    this.endpoint = endpoint;
    this.apiKey = apiKey;
    this.batchSize = 10;
    this.batch = [];
    this.flushInterval = 30000; // 30 seconds
    
    this.startBatchFlush();
  }
  
  track(event) {
    this.batch.push({
      ...event,
      api_key: this.apiKey,
      timestamp: new Date().toISOString()
    });
    
    if (this.batch.length >= this.batchSize) {
      this.flush();
    }
  }
  
  flush() {
    if (this.batch.length === 0) return;
    
    const payload = {
      events: [...this.batch],
      metadata: {
        source: 'documentation_search',
        version: '1.0.0',
        user_agent: navigator.userAgent
      }
    };
    
    fetch(this.endpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': this.apiKey
      },
      body: JSON.stringify(payload)
    }).catch(error => {
      console.warn('Analytics tracking failed:', error);
    });
    
    this.batch = [];
  }
  
  startBatchFlush() {
    setInterval(() => this.flush(), this.flushInterval);
    
    // Flush on page unload
    window.addEventListener('beforeunload', () => this.flush());
  }
}

// Check for user consent before tracking
function shouldTrackAnalytics() {
  // Check for consent cookie/localStorage
  return localStorage.getItem('analytics_consent') === 'true' ||
         getCookie('analytics_consent') === 'true';
}

function trackSearchEvent(query, results) {
  if (!shouldTrackAnalytics()) {
    return; // Don't track without consent
  }
  
  // Proceed with tracking
}