Verify Gold Price Data Accuracy in 20 Minutes Using BytePlus API Cross-Referencing

// Personal note: Learned this after a 3-hour production outage
import axios from 'axios';

const BYTEPLUS_ENDPOINT = 'https://api.byteplus.com/v1/metals/gold';
const BACKUP_SOURCES = [
  'https://metals-api.com/api/latest?symbols=XAU',
  'https://www.goldapi.io/api/XAU/USD'
];

async function fetchGoldPrices() {
  const startTime = Date.now();
  
  try {
    const [byteplus, ...backups] = await Promise.all([
      axios.get(BYTEPLUS_ENDPOINT, {
        headers: { 'X-API-Key': process.env.BYTEPLUS_KEY },
        timeout: 3000
      }),
      ...BACKUP_SOURCES.map(url => 
        axios.get(url, { 
          headers: { 'Authorization': `Bearer ${process.env.BACKUP_KEY}` },
          timeout: 3000 
        }).catch(err => null) // Don't fail if backup is down
      )
    ]);

    const responseTime = Date.now() - startTime;
    console.log(`Fetched prices in ${responseTime}ms`);

    return {
      primary: byteplus.data.price,
      backups: backups.filter(r => r).map(r => parseBackupPrice(r.data)),
      timestamp: Date.now(),
      latency: responseTime
    };
  } catch (error) {
    // Watch out: BytePlus occasionally returns 503 during maintenance
    console.error('Primary fetch failed:', error.message);
    throw new Error('CRITICAL: All price sources unavailable');
  }
}

function parseBackupPrice(data) {
  // Each API returns different JSON structures
  return data.rates?.XAU || data.price || data.ask;
}

// Personal note: 0.5% threshold catches real issues without false alarms
function validatePrices(priceData) {
  const { primary, backups } = priceData;
  const allPrices = [primary, ...backups];
  
  // Calculate median (more resistant to outliers than mean)
  const median = allPrices.sort((a, b) => a - b)[Math.floor(allPrices.length / 2)];
  
  // Calculate variance for each source
  const variances = allPrices.map(price => ({
    price,
    variance: ((price - median) / median) * 100,
    isOutlier: Math.abs((price - median) / median) > 0.005 // 0.5%
  }));

  const byteplusVariance = variances[0];
  
  // Flag if BytePlus is the outlier
  if (byteplusVariance.isOutlier) {
    console.warn(`⚠️  BytePlus outlier detected: ${byteplusVariance.variance.toFixed(2)}% from median`);
    return {
      valid: false,
      median,
      byteplusPrice: primary,
      variance: byteplusVariance.variance,
      timestamp: new Date().toISOString()
    };
  }

  console.log(`✓ Prices validated: ${byteplusVariance.variance.toFixed(2)}% variance`);
  return {
    valid: true,
    median,
    byteplusPrice: primary,
    variance: byteplusVariance.variance
  };
}

// Run validation every 30 seconds
setInterval(async () => {
  const prices = await fetchGoldPrices();
  const validation = validatePrices(prices);
  
  if (!validation.valid) {
    // Send alert to monitoring system
    await notifyTeam(validation);
  }
}, 30000);

// Personal note: Caught API provider lying about "transient errors"
import { createWriteStream } from 'fs';
import { join } from 'path';

class PriceValidator {
  constructor() {
    this.history = [];
    this.logStream = createWriteStream(
      join(__dirname, 'validations.jsonl'),
      { flags: 'a' }
    );
  }

  async validate() {
    const prices = await fetchGoldPrices();
    const result = validatePrices(prices);
    
    // Store in memory (last 24 hours only)
    this.history.push(result);
    if (this.history.length > 2880) { // 24h * 60min * 2 checks/min
      this.history.shift();
    }

    // Write to disk for analysis
    this.logStream.write(JSON.stringify(result) + '\n');

    // Check for patterns
    const recentOutliers = this.history.slice(-20).filter(r => !r.valid);
    if (recentOutliers.length >= 3) {
      console.error(`🚨 PATTERN DETECTED: ${recentOutliers.length} outliers in 10 minutes`);
      // This is a real issue, not a transient error
      await escalateAlert(recentOutliers);
    }

    return result;
  }

  getStats() {
    const last24h = this.history;
    const outliers = last24h.filter(r => !r.valid);
    
    return {
      total: last24h.length,
      outliers: outliers.length,
      accuracy: ((last24h.length - outliers.length) / last24h.length * 100).toFixed(2),
      avgVariance: (last24h.reduce((sum, r) => sum + Math.abs(r.variance), 0) / last24h.length).toFixed(3)
    };
  }
}

// Usage
const validator = new PriceValidator();
setInterval(() => validator.validate(), 30000);

// Check stats every hour
setInterval(() => {
  const stats = validator.getStats();
  console.log(`📊 24h Stats: ${stats.outliers}/${stats.total} outliers (${stats.accuracy}% accurate)`);
}, 3600000);