# Quick checks
curl -o /dev/null -s -w "%{http_code} %{time_total}s\n" https://yourapp.com/health

# Check if the issue is regional
curl -o /dev/null -s -w "%{http_code}\n" --resolve yourapp.com:443:SPECIFIC_IP https://yourapp.com/health

# Find the error
ERROR [2026-02-26T14:47:23Z] PaymentService: 
  Charge failed for user_8a3f — Stripe returned 402

# Now find the request that caused it
grep "user_8a3f" logs | grep "14:47"

# Trace the full request lifecycle
grep "req_id=abc123" logs | sort

# Count errors by type in the last hour
grep "ERROR" logs | grep "14:" | 
  awk '{print $4}' | sort | uniq -c | sort -rn

# Output:
# 847 PaymentService: Charge failed
#  12 AuthService: Token expired
#   3 EmailService: Send failed

// Temporary debug logging behind a flag
async function processPayment(userId: string, amount: number) {
  const debugMode = await getFeatureFlag('debug-payments', userId);
  
  if (debugMode) {
    logger.info('Payment debug', {
      userId,
      amount,
      timestamp: Date.now(),
      stripeConfig: getStripeConfig(),
      userState: await getUserPaymentState(userId),
    });
  }
  
  // ... normal payment logic
}

# List commits in the deploy
git log --oneline v2.45.0..v2.46.0

# Binary search for the breaking commit
git bisect start
git bisect bad v2.46.0
git bisect good v2.45.0
# Deploy each commit git bisect suggests, test, mark good/bad
git bisect good  # or git bisect bad

**Incident Update — 15:30 AEDT**

**Status:** Investigating
**Impact:** ~5% of checkout attempts failing with "Payment Error"
**Duration:** Started ~14:45 AEDT (45 min ago)

**What we know:**
- Stripe is returning 402 errors for a subset of payment attempts
- Affected users have cards issued by [specific bank]
- No code deploys since 11:00

**What we're doing:**
- Checking Stripe status page and contacting support
- Reviewing recent Stripe API changes
- Testing with affected card types in staging

**Next update:** 16:00 AEDT or sooner if status changes

## Incident Postmortem: Checkout Payment Failures
**Date:** 2026-02-26  
**Duration:** 14:45 - 16:20 AEDT (95 minutes)  
**Severity:** SEV2  
**Author:** [Your name]  

### Summary
~5% of checkout payments failed due to a Stripe API behavior change 
affecting 3DS authentication for cards from ANZ Bank.

### Timeline
- 14:45 — First error alerts fire in #alerts-payments
- 14:52 — Engineer begins investigation  
- 15:10 — Identified that only ANZ-issued cards are affected
- 15:25 — Found Stripe changelog noting 3DS flow change
- 15:40 — Hotfix deployed to handle new 3DS response format
- 16:00 — Error rate returns to baseline
- 16:20 — Incident resolved, monitoring confirmed

### Root Cause
Stripe changed the 3DS authentication response format for certain 
card issuers. Our payment handler expected `three_d_secure.status` 
but the new format uses `three_d_secure_result.status`. The code 
fell through to the error handler.

### What Went Well
- Alerts fired within 5 minutes of first error
- Team identified the affected user segment quickly
- Hotfix was deployed within 50 minutes

### What Could Be Better
- We didn't monitor the Stripe changelog for breaking changes
- Our payment handler didn't have a fallback for unknown response formats
- Integration tests didn't cover 3DS edge cases

### Action Items
- [ ] Add Stripe changelog to weekly review (owner: @payments-team)
- [ ] Add defensive parsing for Stripe responses (owner: @alice)
- [ ] Expand payment integration test suite (owner: @bob)
- [ ] Set up contract tests against Stripe's API (owner: @payments-team)

// Every log entry should have these fields
logger.info('Payment processed', {
  requestId: req.id,
  traceId: req.traceId,
  userId: user.id,
  action: 'payment.process',
  amount: payment.amount,
  currency: payment.currency,
  provider: 'stripe',
  duration: Date.now() - startTime,
  success: true,
});

app.get('/health', async (req, res) => {
  const checks = await Promise.allSettled([
    db.query('SELECT 1'),
    redis.ping(),
    fetch('https://api.stripe.com/v1', { method: 'HEAD' }),
  ]);

  const status = checks.every(c => c.status === 'fulfilled') ? 200 : 503;
  
  res.status(status).json({
    status: status === 200 ? 'healthy' : 'degraded',
    checks: {
      database: checks[0].status,
      cache: checks[1].status,
      stripe: checks[2].status,
    },
    timestamp: new Date().toISOString(),
  });
});

class ErrorBoundary extends React.Component<Props, State> {
  static getDerivedStateFromError(error: Error) {
    return { hasError: true, error };
  }

  componentDidCatch(error: Error, info: React.ErrorInfo) {
    reportError({
      error,
      componentStack: info.componentStack,
      route: window.location.pathname,
      userId: this.props.userId,
      buildVersion: process.env.BUILD_VERSION,
      timestamp: new Date().toISOString(),
    });
  }

  render() {
    if (this.state.hasError) {
      return <ErrorFallback error={this.state.error} />;
    }
    return this.props.children;
  }
}