Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

replit-reliability-patterns

/replit-reliability-patterns

Wdraża wzorce niezawodności Replit: circuit breakery, idempotencję i łagodną degradację, dla integracji odpornych na awarie i strategii ponowień.

Repozytorium
agent ↗
Licencja
MIT
Ostatnia zmiana repozytorium
14.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
3
Przestarzałość

Brak sygnałów. Repozytorium zmienione 14.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Wdraża wzorce niezawodności Replit: circuit breakery, idempotencję i łagodną degradację, dla integracji odpornych na awarie i strategii ponowień.

Wyzwalacze z opisu

replit reliabilityreplit circuit breakerreplit idempotentreplit resiliencereplit fallbackreplit bulkhead
Oryginalny opis (EN)

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".

Jak działa

  1. Overview
  2. Prerequisites
  3. Circuit Breaker
  4. Idempotency Keys
  5. Bulkhead Pattern
  6. Timeout Hierarchy
  7. Graceful Degradation
  8. Dead Letter Queue
  9. Health Check with Degraded State
  10. Instructions
Sekcje z nagłówków SKILL.md, w oryginale · 277 linii, 780 słów
Podgląd SKILL.md
---
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 <jeremy@intentsolutions.io>
---

# 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<any>) => 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<T>(fn: () => Promise<T>): Promise<T> {
  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, 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

```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<T>(
  priority: 'critical' | 'normal' | 'bulk',
  fn: () => Promise<T>
): Promise<T> {
  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<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(`Replit ${operation} timeout`)), timeout)
    ),
  ]);
}
```

## Graceful Degradation

```typescript
interface ReplitFallback {
  enabled: boolean;
  data: any;
  staleness: 'fresh' | 'stale' | 'very_stale';
}

async function withReplitFallback<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('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<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 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<string, any>;
}> {
  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`.

Wersje

W bazie nie ma innych skilli o nazwie replit-reliability-patterns.

Migawka bazy z 13.11.2026 · wersja paczki f5b61260536b (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100windsurf-reliability-patterns
    Wdraża wzorce niezawodności Windsurf: circuit breakery, idempotentność i łagodną degradację, dla odpornych integracji i strategii ponawiania.
  • 100exa-reliability-patterns
    Wdraża wzorce niezawodności Exa: circuit breakers, idempotencję i łagodną degradację, w odpornych integracjach produkcyjnych.
  • 100shopify-reliability-patterns
    Wdraża wzorce niezawodności aplikacji Shopify: bezpieczniki na awarie API, obsługę ponowień webhooków i łagodną degradację dla odpornych integracji.
  • 100customerio-reliability-patterns
    Wdraża wzorce niezawodności i odporności na awarie w integracjach Customer.io: circuit breakery, kolejki zapasowe, idempotencję i łagodną degradację.
  • 100reliability
    Wymusza przy zmianach kodu łagodną degradację, poprawną obsługę błędów, strategie ponawiania i wzorce odporne na awarie, na przykład circuit breaker.
  • 100error-handling
    Wdraża wzorce obsługi błędów, ustrukturyzowane logowanie, strategie ponawiania, circuit breakery i łagodną degradację, także przy alertach i agregacji logów.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.