--- name: replit-reliability-patterns description: | Implement Replit reliability patterns including circuit breakers, idempotency, and graceful degradation. Use when building fault-tolerant Replit integrations, implementing retry strategies, or adding resilience to production Replit services. Trigger with phrases like "replit reliability", "replit circuit breaker", "replit idempotent", "replit resilience", "replit fallback", "replit bulkhead". allowed-tools: Read, Write, Edit version: 1.0.0 license: MIT author: Jeremy Longshore --- # Replit Reliability Patterns ## Overview Production-grade reliability patterns for Replit integrations. ## Prerequisites - Understanding of circuit breaker pattern - opossum or similar library installed - Queue infrastructure for DLQ - Caching layer for fallbacks ## Circuit Breaker ```typescript import CircuitBreaker from 'opossum'; const replitBreaker = new CircuitBreaker( async (operation: () => Promise) => operation(), { timeout: 30000, errorThresholdPercentage: 50, resetTimeout: 30000, volumeThreshold: 10, } ); // Events replitBreaker.on('open', () => { console.warn('Replit circuit OPEN - requests failing fast'); alertOps('Replit circuit breaker opened'); }); replitBreaker.on('halfOpen', () => { console.info('Replit circuit HALF-OPEN - testing recovery'); }); replitBreaker.on('close', () => { console.info('Replit circuit CLOSED - normal operation'); }); // Usage async function safeReplitCall(fn: () => Promise): Promise { return replitBreaker.fire(fn); } ``` ## Idempotency Keys ```typescript import { v4 as uuidv4 } from 'uuid'; import crypto from 'crypto'; // Generate deterministic idempotency key from input function generateIdempotencyKey( operation: string, params: Record ): string { const data = JSON.stringify({ operation, params }); return crypto.createHash('sha256').update(data).digest('hex'); } // Or use random key with storage class IdempotencyManager { private store: Map = new Map(); getOrCreate(operationId: string): string { const existing = this.store.get(operationId); if (existing && existing.expiresAt > new Date()) { return existing.key; } const key = uuidv4(); this.store.set(operationId, { key, expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), }); return key; } } ``` ## Bulkhead Pattern ```typescript import PQueue from 'p-queue'; // Separate queues for different operations const replitQueues = { critical: new PQueue({ concurrency: 10 }), normal: new PQueue({ concurrency: 5 }), bulk: new PQueue({ concurrency: 2 }), }; async function prioritizedReplitCall( priority: 'critical' | 'normal' | 'bulk', fn: () => Promise ): Promise { return replitQueues[priority].add(fn); } // Usage await prioritizedReplitCall('critical', () => replitClient.processPayment(order) ); await prioritizedReplitCall('bulk', () => replitClient.syncCatalog(products) ); ``` ## Timeout Hierarchy ```typescript const TIMEOUT_CONFIG = { connect: 5000, // Initial connection request: 30000, // Standard requests upload: 120000, // File uploads longPoll: 300000, // Webhook long-polling }; async function timedoutReplitCall( operation: 'connect' | 'request' | 'upload' | 'longPoll', fn: () => Promise ): Promise { const timeout = TIMEOUT_CONFIG[operation]; return Promise.race([ fn(), new Promise((_, reject) => setTimeout(() => reject(new Error(`Replit ${operation} timeout`)), timeout) ), ]); } ``` ## Graceful Degradation ```typescript interface ReplitFallback { enabled: boolean; data: any; staleness: 'fresh' | 'stale' | 'very_stale'; } async function withReplitFallback( fn: () => Promise, fallbackFn: () => Promise ): Promise<{ data: T; fallback: boolean }> { try { const data = await fn(); // Update cache for future fallback await updateFallbackCache(data); return { data, fallback: false }; } catch (error) { console.warn('Replit failed, using fallback:', error.message); const data = await fallbackFn(); return { data, fallback: true }; } } ``` ## Dead Letter Queue ```typescript interface DeadLetterEntry { id: string; operation: string; payload: any; error: string; attempts: number; lastAttempt: Date; } class ReplitDeadLetterQueue { private queue: DeadLetterEntry[] = []; add(entry: Omit): void { this.queue.push({ ...entry, id: uuidv4(), lastAttempt: new Date(), }); } async processOne(): Promise { const entry = this.queue.shift(); if (!entry) return false; try { await replitClient[entry.operation](entry.payload); console.log(`DLQ: Successfully reprocessed ${entry.id}`); return true; } catch (error) { entry.attempts++; entry.lastAttempt = new Date(); if (entry.attempts < 5) { this.queue.push(entry); } else { console.error(`DLQ: Giving up on ${entry.id} after 5 attempts`); await alertOnPermanentFailure(entry); } return false; } } } ``` ## Health Check with Degraded State ```typescript type HealthStatus = 'healthy' | 'degraded' | 'unhealthy'; async function replitHealthCheck(): Promise<{ status: HealthStatus; details: Record; }> { const checks = { api: await checkApiConnectivity(), circuitBreaker: replitBreaker.stats(), dlqSize: deadLetterQueue.size(), }; const status: HealthStatus = !checks.api.connected ? 'unhealthy' : checks.circuitBreaker.state === 'open' ? 'degraded' : checks.dlqSize > 100 ? 'degraded' : 'healthy'; return { status, details: checks }; } ``` ## Instructions ### Step 1: Implement Circuit Breaker Wrap Replit calls with circuit breaker. ### Step 2: Add Idempotency Keys Generate deterministic keys for operations. ### Step 3: Configure Bulkheads Separate queues for different priorities. ### Step 4: Set Up Dead Letter Queue Handle permanent failures gracefully. ## Output - Circuit breaker protecting Replit calls - Idempotency preventing duplicates - Bulkhead isolation implemented - DLQ for failed operations ## Error Handling | Issue | Cause | Solution | |-------|-------|----------| | Circuit stays open | Threshold too low | Adjust error percentage | | Duplicate operations | Missing idempotency | Add idempotency key | | Queue full | Rate too high | Increase concurrency | | DLQ growing | Persistent failures | Investigate root cause | ## Examples ### Quick Circuit Check ```typescript const state = replitBreaker.stats().state; console.log('Replit circuit:', state); ``` ## Resources - [Circuit Breaker Pattern](https://martinfowler.com/bliki/CircuitBreaker.html) - [Opossum Documentation](https://nodeshift.dev/opossum/) - [Replit Reliability Guide](https://docs.replit.com/reliability) ## Next Steps For policy enforcement, see `replit-policy-guardrails`.

replit-reliability-patterns

Install this skill

Comments