Fix Gold Price API Failures with Multi-Source Fallback in 20 Minutes

// Personal note: Learned the hard way to include rate limits after hitting them all in one day
const GOLD_SOURCES = [
  {
    name: 'metals-dev',
    url: 'https://api.metals.dev/v1/latest',
    priority: 1,
    rateLimit: { requests: 100, window: 3600000 }, // 100/hour
    timeout: 5000,
    apiKey: process.env.METALS_DEV_KEY
  },
  {
    name: 'goldapi-io',
    url: 'https://www.goldapi.io/api/XAU/USD',
    priority: 2,
    rateLimit: { requests: 50, window: 3600000 }, // 50/hour
    timeout: 8000,
    apiKey: process.env.GOLDAPI_KEY
  },
  {
    name: 'xe-backup',
    url: 'https://www.xe.com/api/protected/midmarket-converter',
    priority: 3,
    rateLimit: { requests: 10, window: 3600000 }, // 10/hour - emergency only
    timeout: 10000,
    apiKey: process.env.XE_API_KEY
  }
];

// Watch out: Don't put API keys in code - use environment variables
const MAX_PRICE_AGE_MS = 90000; // 90 seconds - gold moves fast

// Personal note: This took 4 rewrites to handle all edge cases
class GoldPriceFetcher {
  constructor() {
    this.cache = { price: null, timestamp: null, source: null };
    this.rateLimitCounters = new Map();
  }

  async getPrice() {
    // Return cached if fresh enough
    if (this.isCacheFresh()) {
      console.log(`✓ Using cached price from ${this.cache.source}`);
      return this.cache;
    }

    // Try each source in priority order
    for (const source of GOLD_SOURCES) {
      if (this.isRateLimited(source)) {
        console.log(`⊠ Skipping ${source.name} - rate limited`);
        continue;
      }

      try {
        const price = await this.fetchFromSource(source);
        this.updateCache(price, source.name);
        return this.cache;
      } catch (error) {
        console.log(`✗ ${source.name} failed: ${error.message}`);
        // Continue to next source
      }
    }

    // All sources failed - return stale cache if available
    if (this.cache.price) {
      console.warn('⚠ All sources failed - returning stale cache');
      return { ...this.cache, stale: true };
    }

    throw new Error('All gold price sources unavailable');
  }

  async fetchFromSource(source) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), source.timeout);

    try {
      const response = await fetch(source.url, {
        headers: { 'Authorization': `Bearer ${source.apiKey}` },
        signal: controller.signal
      });

      if (response.status === 429) {
        this.markRateLimited(source);
        throw new Error('Rate limited');
      }

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }

      const data = await response.json();
      const price = this.extractPrice(data, source.name);
      
      // Watch out: Validate price is reasonable (prevent bad data)
      if (price < 1000 || price > 5000) {
        throw new Error(`Suspicious price: $${price}`);
      }

      this.incrementRateLimit(source);
      return price;

    } finally {
      clearTimeout(timeoutId);
    }
  }

  isCacheFresh() {
    if (!this.cache.timestamp) return false;
    return (Date.now() - this.cache.timestamp) < MAX_PRICE_AGE_MS;
  }

  isRateLimited(source) {
    const counter = this.rateLimitCounters.get(source.name);
    if (!counter) return false;
    
    const timeSinceReset = Date.now() - counter.resetTime;
    if (timeSinceReset > source.rateLimit.window) {
      this.rateLimitCounters.delete(source.name);
      return false;
    }
    
    return counter.count >= source.rateLimit.requests;
  }

  extractPrice(data, sourceName) {
    // Each API returns different JSON structure
    const extractors = {
      'metals-dev': (d) => d.rates.XAU,
      'goldapi-io': (d) => d.price,
      'xe-backup': (d) => d.to[0].mid
    };
    return extractors[sourceName](data);
  }

  // Implementation details for rate limiting and cache...
}

class SourceHealthMonitor {
  constructor() {
    this.stats = new Map();
    GOLD_SOURCES.forEach(source => {
      this.stats.set(source.name, {
        attempts: 0,
        successes: 0,
        failures: 0,
        avgResponseTime: 0,
        lastSuccess: null,
        lastFailure: null
      });
    });
  }

  recordAttempt(sourceName, success, responseTime, error = null) {
    const stat = this.stats.get(sourceName);
    stat.attempts++;
    
    if (success) {
      stat.successes++;
      stat.lastSuccess = new Date();
      stat.avgResponseTime = (stat.avgResponseTime * (stat.successes - 1) + responseTime) / stat.successes;
    } else {
      stat.failures++;
      stat.lastFailure = { time: new Date(), error: error?.message };
    }
  }

  getHealthReport() {
    const report = [];
    this.stats.forEach((stat, name) => {
      const successRate = stat.attempts > 0 
        ? (stat.successes / stat.attempts * 100).toFixed(1)
        : 0;
      
      report.push({
        source: name,
        successRate: `${successRate}%`,
        avgResponse: `${stat.avgResponseTime.toFixed(0)}ms`,
        lastSuccess: stat.lastSuccess?.toISOString() || 'never',
        status: successRate > 95 ? 'healthy' : successRate > 70 ? 'degraded' : 'failing'
      });
    });
    return report;
  }
}

// Usage: Log health every hour
const monitor = new SourceHealthMonitor();
setInterval(() => {
  console.table(monitor.getHealthReport());
}, 3600000);

// Test script - run this before deploying
async function testFailover() {
  const fetcher = new GoldPriceFetcher();
  
  console.log('Test 1: Normal operation');
  const price1 = await fetcher.getPrice();
  console.log(`✓ Got price: $${price1.price} from ${price1.source}`);
  
  console.log('\nTest 2: Primary API down (simulated)');
  // Temporarily break primary
  const originalUrl = GOLD_SOURCES[0].url;
  GOLD_SOURCES[0].url = 'https://fake-api-that-fails.com';
  
  const price2 = await fetcher.getPrice();
  console.log(`✓ Failover worked: $${price2.price} from ${price2.source}`);
  
  GOLD_SOURCES[0].url = originalUrl; // Restore
  
  console.log('\nTest 3: All APIs down (simulated)');
  const backupUrls = GOLD_SOURCES.map(s => s.url);
  GOLD_SOURCES.forEach(s => s.url = 'https://fake-api-that-fails.com');
  
  try {
    await fetcher.getPrice();
  } catch (error) {
    console.log(`✓ Correct error handling: ${error.message}`);
  }
  
  // Restore all
  GOLD_SOURCES.forEach((s, i) => s.url = backupUrls[i]);
  
  console.log('\n✓ All tests passed');
}