windsurf-reliability-patterns
Implement Windsurf reliability patterns including circuit breakers, idempotency, and graceful degradation.Use when building fault-tolerant Windsurf integrations, implementing retry strategies,or adding resilience to production Windsurf services.Trigger with phrases like "windsurf reliability", "windsurf circuit breaker","windsurf idempotent", "windsurf resilience", "windsurf fallback", "windsurf bulkhead".
When & Why to Use This Skill
This Claude skill provides a comprehensive suite of production-grade reliability patterns specifically designed for Windsurf integrations. It empowers developers to build fault-tolerant and resilient systems by implementing essential architectural strategies such as circuit breakers, idempotency keys, bulkheads, and dead letter queues. By integrating these patterns, users can ensure high availability, prevent cascading failures, and maintain data consistency in production environments.
Use Cases
- Case 1: Implementing Circuit Breakers to automatically fail fast and protect Windsurf services from cascading failures during downstream outages.
- Case 2: Ensuring data integrity and preventing duplicate transactions by generating and managing deterministic Idempotency Keys for API operations.
- Case 3: Utilizing the Bulkhead pattern to isolate critical system resources, ensuring that high-priority Windsurf tasks remain responsive even under heavy load.
- Case 4: Setting up Graceful Degradation and fallback mechanisms to provide cached or simplified data when primary Windsurf services are unavailable.
- Case 5: Managing persistent failures through Dead Letter Queues (DLQ) to allow for systematic error analysis and manual reprocessing of failed operations.
| name | windsurf-reliability-patterns |
|---|---|
| description | | |
| allowed-tools | Read, Write, Edit |
| version | 1.0.0 |
| license | MIT |
| author | Jeremy Longshore <jeremy@intentsolutions.io> |
Windsurf Reliability Patterns
Overview
Production-grade reliability patterns for Windsurf integrations.
Prerequisites
- Understanding of circuit breaker pattern
- opossum or similar library installed
- Queue infrastructure for DLQ
- Caching layer for fallbacks
Circuit Breaker
import CircuitBreaker from 'opossum';
const windsurfBreaker = new CircuitBreaker(
async (operation: () => Promise<any>) => operation(),
{
timeout: 30000,
errorThresholdPercentage: 50,
resetTimeout: 30000,
volumeThreshold: 10,
}
);
// Events
windsurfBreaker.on('open', () => {
console.warn('Windsurf circuit OPEN - requests failing fast');
alertOps('Windsurf circuit breaker opened');
});
windsurfBreaker.on('halfOpen', () => {
console.info('Windsurf circuit HALF-OPEN - testing recovery');
});
windsurfBreaker.on('close', () => {
console.info('Windsurf circuit CLOSED - normal operation');
});
// Usage
async function safeWindsurfCall<T>(fn: () => Promise<T>): Promise<T> {
return windsurfBreaker.fire(fn);
}
Idempotency Keys
import { v4 as uuidv4 } from 'uuid';
import crypto from 'crypto';
// Generate deterministic idempotency key from input
function generateIdempotencyKey(
operation: string,
params: Record<string, any>
): 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<string, { key: string; expiresAt: Date }> = 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
import PQueue from 'p-queue';
// Separate queues for different operations
const windsurfQueues = {
critical: new PQueue({ concurrency: 10 }),
normal: new PQueue({ concurrency: 5 }),
bulk: new PQueue({ concurrency: 2 }),
};
async function prioritizedWindsurfCall<T>(
priority: 'critical' | 'normal' | 'bulk',
fn: () => Promise<T>
): Promise<T> {
return windsurfQueues[priority].add(fn);
}
// Usage
await prioritizedWindsurfCall('critical', () =>
windsurfClient.processPayment(order)
);
await prioritizedWindsurfCall('bulk', () =>
windsurfClient.syncCatalog(products)
);
Timeout Hierarchy
const TIMEOUT_CONFIG = {
connect: 5000, // Initial connection
request: 30000, // Standard requests
upload: 120000, // File uploads
longPoll: 300000, // Webhook long-polling
};
async function timedoutWindsurfCall<T>(
operation: 'connect' | 'request' | 'upload' | 'longPoll',
fn: () => Promise<T>
): Promise<T> {
const timeout = TIMEOUT_CONFIG[operation];
return Promise.race([
fn(),
new Promise<never>((_, reject) =>
setTimeout(() => reject(new Error(`Windsurf ${operation} timeout`)), timeout)
),
]);
}
Graceful Degradation
interface WindsurfFallback {
enabled: boolean;
data: any;
staleness: 'fresh' | 'stale' | 'very_stale';
}
async function withWindsurfFallback<T>(
fn: () => Promise<T>,
fallbackFn: () => Promise<T>
): 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('Windsurf failed, using fallback:', error.message);
const data = await fallbackFn();
return { data, fallback: true };
}
}
Dead Letter Queue
interface DeadLetterEntry {
id: string;
operation: string;
payload: any;
error: string;
attempts: number;
lastAttempt: Date;
}
class WindsurfDeadLetterQueue {
private queue: DeadLetterEntry[] = [];
add(entry: Omit<DeadLetterEntry, 'id' | 'lastAttempt'>): void {
this.queue.push({
...entry,
id: uuidv4(),
lastAttempt: new Date(),
});
}
async processOne(): Promise<boolean> {
const entry = this.queue.shift();
if (!entry) return false;
try {
await windsurfClient[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
type HealthStatus = 'healthy' | 'degraded' | 'unhealthy';
async function windsurfHealthCheck(): Promise<{
status: HealthStatus;
details: Record<string, any>;
}> {
const checks = {
api: await checkApiConnectivity(),
circuitBreaker: windsurfBreaker.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 Windsurf 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 Windsurf 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
const state = windsurfBreaker.stats().state;
console.log('Windsurf circuit:', state);
Resources
Next Steps
For policy enforcement, see windsurf-policy-guardrails.