Production Migration Guide

# Development (current)
BOOP_ENV=development
BOOP_VENDOR_ID=ven_dev_your_id
BOOP_API_KEY=sk_dev_your_secret_key
BOOP_BASE_URL=https://dev.app.boop.it

# Production (new)
BOOP_ENV=production
BOOP_VENDOR_ID=ven_live_your_id
BOOP_API_KEY=sk_live_your_secret_key
BOOP_BASE_URL=https://app.boop.it

class BoopClient {
  constructor(config) {
    this.config = config;

    // Safety check for production
    if (this.isProduction() && !process.env.CONFIRM_PRODUCTION) {
      throw new Error(
        'Production environment detected. Set CONFIRM_PRODUCTION=true to confirm.'
      );
    }
  }

  isProduction() {
    return this.config.baseUrl.includes('app.boop.it');
  }

  async authenticate(contextData) {
    if (this.isProduction()) {
      console.log('🚀 Using PRODUCTION BOOP environment');
    } else {
      console.log('🧪 Using DEVELOPMENT BOOP environment');
    }

    // ... authentication logic
  }
}

// Feature flag based routing
class PaymentRouter {
  constructor() {
    this.boopTrafficPercentage = parseInt(process.env.BOOP_TRAFFIC_PERCENT || '0');
  }

  shouldUseBoop(userId) {
    // Consistent user routing based on hash
    const userHash = this.hashUserId(userId);
    return userHash % 100 < this.boopTrafficPercentage;
  }

  async processPayment(userId, amount) {
    if (this.shouldUseBoop(userId)) {
      return await this.processBoopPayment(amount);
    } else {
      return await this.processLegacyPayment(amount);
    }
  }

  hashUserId(userId) {
    // Simple hash function for consistent routing
    return userId.split('').reduce((hash, char) => {
      return ((hash << 5) - hash + char.charCodeAt(0)) & 0xfffffff;
    }, 0);
  }
}

# Test production health endpoint
curl https://app.boop.it/health

# Expected response
{
  "status": "ok",
  "version": "a1b2c3d"
}

// Production authentication test
const testProductionAuth = async () => {
  console.log('🔬 Testing production authentication...');

  const testConfig = {
    baseUrl: 'https://app.boop.it',
    vendorId: process.env.BOOP_PROD_VENDOR_ID,
    apiKey: process.env.BOOP_PROD_API_KEY,
    wsEndpoint: 'wss://app.boop.it/ws/vendor'
  };

  const client = new BoopClient(testConfig);

  try {
    // Test with minimal risk transaction
    const result = await client.authenticate({
      type: 'entrance',
      attributes: ['pseudonym']
    });

    if (result.success) {
      console.log('✅ Production authentication successful');
      return true;
    } else {
      console.error('❌ Production authentication failed:', result.error);
      return false;
    }
  } catch (error) {
    console.error('💥 Production test error:', error);
    return false;
  }
};

// Run verification
testProductionAuth()
  .then(success => {
    if (success) {
      console.log('🚀 Ready for production traffic');
    } else {
      console.log('🛑 Production issues detected - investigate before proceeding');
    }
  });

// Example monitoring configuration
const alertThresholds = {
  authentication: {
    errorRate: 1.0, // Alert if > 1% errors
    responseTime: 3000, // Alert if > 3 seconds
    successRate: 99.0 // Alert if < 99% success
  },
  payments: {
    errorRate: 0.1, // Alert if > 0.1% errors
    responseTime: 2000, // Alert if > 2 seconds
    successRate: 99.5 // Alert if < 99.5% success
  },
  infrastructure: {
    uptime: 99.0, // Alert if < 99% uptime
    connectionFailures: 5 // Alert if > 5 failures per minute
  }
};

// Implement monitoring logic based on your platform
// (DataDog, New Relic, CloudWatch, etc.)

class AutoRollbackMonitor {
  constructor(thresholds) {
    this.thresholds = thresholds;
    this.consecutiveFailures = 0;
    this.maxFailures = 5;
  }

  checkMetrics(metrics) {
    const issues = [];

    if (metrics.errorRate > this.thresholds.errorRate) {
      issues.push(`Error rate ${metrics.errorRate}% exceeds threshold ${this.thresholds.errorRate}%`);
    }

    if (metrics.responseTime > this.thresholds.responseTime) {
      issues.push(`Response time ${metrics.responseTime}ms exceeds threshold ${this.thresholds.responseTime}ms`);
    }

    if (issues.length > 0) {
      this.consecutiveFailures++;

      if (this.consecutiveFailures >= this.maxFailures) {
        this.triggerRollback(issues);
      }
    } else {
      this.consecutiveFailures = 0;
    }
  }

  triggerRollback(issues) {
    console.error('🚨 AUTOMATIC ROLLBACK TRIGGERED');
    console.error('Issues detected:', issues);

    // Implement rollback logic:
    // 1. Switch traffic back to previous system
    // 2. Alert engineering team
    // 3. Preserve logs for analysis

    this.executeRollback();
  }

  executeRollback() {
    // Implementation depends on your deployment strategy
    // Examples:
    // - Feature flag toggle
    // - Traffic routing change
    // - Container rollback
    // - DNS switch
  }
}