@wenathlan/saddle 1.8.17 → 2.0.2

package/docs/plans/15.research.retry.rate.limit.md

@@ -1,1958 +0,0 @@
-# Pesquisa: Retry, Backoff e Rate Limiting (2026)
-
-## Sumário
-
-1. [Pacotes de Retry](#1-pacotes-de-retry)
-2. [Comparação p-retry vs async-retry](#2-comparação-p-retry-vs-async-retry)
-3. [Algoritmos de Rate Limiting](#3-algoritmos-de-rate-limiting)
-4. [Pacotes de Rate Limiting](#4-pacotes-de-rate-limiting)
-5. [Rate Limiting por Domínio](#5-rate-limiting-por-dominio)
-6. [Status Codes para Retry](#6-status-para-retry)
-7. [Respeitando Retry-After](#7-respeitando-retry-after)
-8. [Retry com Proxy Rotation](#8-retry-com-proxy-rotation)
-9. [Exemplos Completos](#9-exemplos-completos)
-
----
-
-## 1. Pacotes de Retry
-
-### 1.1 p-retry (Recomendado)
-
-**Versão:** 8.0.0  
-**Descrição:** Retry com suporte a AbortError e callbacks  
-**Última atualização:** 2024
-
-```javascript
-import pRetry from 'p-retry';
-
-// Uso básico
-const result = await pRetry(async () => {
-  const response = await fetch('https://example.com');
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-  }
-  return response.json();
-}, {
-  retries: 3,
-  factor: 2,
-  minTimeout: 1000,
-  maxTimeout: 10000,
-  randomize: true,
-});
-
-// Com AbortController
-const controller = new AbortController();
-setTimeout(() => controller.abort(), 5000);
-
-const result = await pRetry(async (attemptNumber) => {
-  console.log(`Attempt ${attemptNumber}`);
-  
-  const response = await fetch('https://example.com', {
-    signal: controller.signal,
-  });
-  
-  if (!response.ok) {
-    throw new pRetry.AbortError(new Error(`Abort on ${response.status}`));
-  }
-  
-  return response.json();
-}, {
-  retries: 5,
-  onFailedAttempt: async (error) => {
-    console.log(`Attempt ${error.attemptNumber} failed`);
-    console.log(`Failures: ${error.retriesLeft}`);
-    
-    // Abort em caso de erro 401/403
-    if (error.message.includes('401') || error.message.includes('403')) {
-      throw new pRetry.AbortError(error);
-    }
-  },
-});
-```
-
-**Configuração avançada:**
-```javascript
-import pRetry from 'p-retry';
-
-const result = await pRetry(async () => {
-  // Lógica de retry
-}, {
-  retries: 5,                    // Número máximo de retries
-  factor: 2,                     // Fator de backoff exponencial
-  minTimeout: 1000,              // Timeout mínimo (1s)
-  maxTimeout: 60000,             // Timeout máximo (60s)
-  randomize: true,               // Adicionar aleatoriedade
-  signal: controller.signal,     // AbortSignal
-  onFailedAttempt: async (error) => {
-    // Callback após cada falha
-    console.log(`Attempt ${error.attemptNumber} failed`);
-    console.log(`Retries left: ${error.retriesLeft}`);
-  },
-});
-```
-
-### 1.2 async-retry
-
-**Versão:** 1.3.3  
-**Descrição:** Retry com suporte a bail function  
-**Última atualização:** 2023
-
-```javascript
-import retry from 'async-retry';
-
-// Uso básico
-const result = await retry(async (bail) => {
-  const response = await fetch('https://example.com');
-  
-  // Bail em caso de erro 401
-  if (response.status === 401) {
-    bail(new Error('Unauthorized'));
-    return;
-  }
-  
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-  }
-  
-  return response.json();
-}, {
-  retries: 3,
-  factor: 2,
-  minTimeout: 1000,
-  maxTimeout: 10000,
-  randomize: true,
-});
-
-// Com retry callback
-const result = await retry(async (bail) => {
-  // Lógica de retry
-}, {
-  retries: 5,
-  onRetry: (error, attempt) => {
-    console.log(`Attempt ${attempt} failed, retrying...`);
-  },
-});
-```
-
-**Configuração avançada:**
-```javascript
-import retry from 'async-retry';
-
-const result = await retry(async (bail) => {
-  // Lógica de retry
-}, {
-  retries: 5,                    // Número máximo de retries
-  factor: 2,                     // Fator de backoff exponencial
-  minTimeout: 1000,              // Timeout mínimo (1s)
-  maxTimeout: 60000,             // Timeout máximo (60s)
-  randomize: true,               // Adicionar aleatoriedade
-  bail: (error) => {
-    // Função para parar retries
-    return error.message.includes('401');
-  },
-  onRetry: (error, attempt) => {
-    // Callback após cada falha
-    console.log(`Attempt ${attempt} failed`);
-  },
-});
-```
-
-### 1.3 retry
-
-**Versão:** 0.13.1  
-**Descrição:** Biblioteca fundacional de retry  
-**Última atualização:** 2022
-
-```javascript
-import retry from 'retry';
-
-// Uso com callbacks
-const operation = retry.operation({
-  retries: 5,
-  factor: 2,
-  minTimeout: 1000,
-  maxTimeout: 60000,
-  randomize: true,
-});
-
-operation.attempt(async (currentAttempt) => {
-  try {
-    const response = await fetch('https://example.com');
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-    const data = await response.json();
-    operation.stop();
-    return data;
-  } catch (error) {
-    if (operation.retry(error)) {
-      console.log(`Attempt ${currentAttempt} failed, retrying...`);
-    } else {
-      console.log(`All retries exhausted`);
-      throw error;
-    }
-  }
-});
-
-// Uso com Promises
-import { promisify } from 'util';
-const retryAsync = promisify(retry);
-
-const result = await retryAsync(async () => {
-  const response = await fetch('https://example.com');
-  return response.json();
-}, {
-  retries: 5,
-  factor: 2,
-  minTimeout: 1000,
-  maxTimeout: 60000,
-});
-```
-
-### 1.4 exponential-backoff
-
-**Versão:** 3.1.3  
-**Descrição:** Geração de delays com backoff exponencial  
-**Última atualização:** 2023
-
-```javascript
-import { ExponentialBackoff } from 'exponential-backoff';
-
-// Uso básico
-const backoff = new ExponentialBackoff({
-  maxRetries: 5,
-  initialDelay: 1000,
-  maxDelay: 60000,
-  factor: 2,
-  jitter: true,
-});
-
-const result = await backoff.execute(async () => {
-  const response = await fetch('https://example.com');
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-  }
-  return response.json();
-});
-
-// Uso com delay manual
-import { getDelay } from 'exponential-backoff';
-
-for (let i = 0; i < 5; i++) {
-  const delay = getDelay(i, {
-    initialDelay: 1000,
-    maxDelay: 60000,
-    factor: 2,
-    jitter: true,
-  });
-  
-  console.log(`Attempt ${i + 1} will wait ${delay}ms`);
-}
-```
-
----
-
-## 2. Comparação p-retry vs async-retry
-
-### Tabela Comparativa
-
-| Característica | p-retry 8.0.0 | async-retry 1.3.3 |
-|----------------|---------------|-------------------|
-| **Tipo** | ESM/CommonJS | CommonJS |
-| **AbortError** | Nativo | Via bail |
-| **Callbacks** | onFailedAttempt | onRetry |
-| **Bail** | AbortError | bail function |
-| **Signal** | AbortSignal | Não suporta |
-| **Fator de backoff** | Configurável | Configurável |
-| **Jitter** | Configurável | Configurável |
-| **Última atualização** | 2024 | 2023 |
-| **Manutenção** | Ativa | Estável |
-| **Bundle size** | ~2KB | ~1.5KB |
-
-### Quando Usar Cada Um
-
-**Use p-retry quando:**
-- Precisa de AbortController/AbortSignal
-- Quer callbacks detalhados (onFailedAttempt)
-- Usa ESM nativo
-- Precisa de granularidade no controle de retry
-
-**Use async-retry quando:**
-- Prefere API com bail function
-- Usa CommonJS
-- Projeto já usa async-retry
-- Não precisa de AbortSignal
-
-### Exemplo Comparativo
-
-```javascript
-// p-retry
-import pRetry from 'p-retry';
-
-const result1 = await pRetry(async (attempt) => {
-  const response = await fetch('https://example.com');
-  if (response.status === 429) {
-    throw new Error('Rate limited');
-  }
-  return response.json();
-}, {
-  retries: 3,
-  onFailedAttempt: async (error) => {
-    console.log(`Attempt ${error.attemptNumber} failed`);
-  },
-});
-
-// async-retry
-import retry from 'async-retry';
-
-const result2 = await retry(async (bail) => {
-  const response = await fetch('https://example.com');
-  if (response.status === 429) {
-    bail(new Error('Rate limited'));
-    return;
-  }
-  return response.json();
-}, {
-  retries: 3,
-  onRetry: (error, attempt) => {
-    console.log(`Attempt ${attempt} failed`);
-  },
-});
-```
-
----
-
-## 3. Algoritmos de Rate Limiting
-
-### 3.1 Token Bucket
-
-**Como funciona:**
-- Bucket contém N tokens
-- Cada request consome 1 token
-- Tokens são adicionados a uma taxa fixa
-- Se bucket vazio, request é rejeitado
-
-**Vantagens:**
-- Permite bursts curtos
-- Simples de implementar
-- Baixa memória
-
-**Desvantagens:**
-- Não garante taxa suave
-- Burst pode sobrecarregar sistema
-
-```javascript
-class TokenBucket {
-  constructor(capacity, refillRate) {
-    this.capacity = capacity;
-    this.tokens = capacity;
-    this.refillRate = refillRate; // tokens por segundo
-    this.lastRefill = Date.now();
-  }
-
-  consume() {
-    this.refill();
-    if (this.tokens > 0) {
-      this.tokens--;
-      return true;
-    }
-    return false;
-  }
-
-  refill() {
-    const now = Date.now();
-    const elapsed = (now - this.lastRefill) / 1000;
-    const tokensToAdd = elapsed * this.refillRate;
-    this.tokens = Math.min(this.capacity, this.tokens + tokensToAdd);
-    this.lastRefill = now;
-  }
-
-  getTokens() {
-    this.refill();
-    return Math.floor(this.tokens);
-  }
-}
-
-// Uso
-const bucket = new TokenBucket(10, 1); // 10 tokens, 1 por segundo
-
-async function makeRequest() {
-  if (bucket.consume()) {
-    return await fetch('https://example.com');
-  } else {
-    throw new Error('Rate limited');
-  }
-}
-```
-
-### 3.2 Sliding Window Log
-
-**Como funciona:**
-- Mantém log de todos os requests no último período
-- Conta requests no período atual
-- Se count > limit, rejeita
-
-**Vantagens:**
-- Preciso
-- Sem edge cases
-
-**Desvantagens:**
-- Alta memória (armazena todos os timestamps)
-- Computacionalmente caro
-
-```javascript
-class SlidingWindowLog {
-  constructor(windowSize, maxRequests) {
-    this.windowSize = windowSize; // em ms
-    this.maxRequests = maxRequests;
-    this.logs = [];
-  }
-
-  isAllowed() {
-    const now = Date.now();
-    const windowStart = now - this.windowSize;
-
-    // Remover logs antigos
-    this.logs = this.logs.filter(time => time > windowStart);
-
-    if (this.logs.length < this.maxRequests) {
-      this.logs.push(now);
-      return true;
-    }
-
-    return false;
-  }
-
-  getCount() {
-    const now = Date.now();
-    const windowStart = now - this.windowSize;
-    return this.logs.filter(time => time > windowStart).length;
-  }
-}
-
-// Uso
-const limiter = new SlidingWindowLog(60000, 100); // 100 requests por minuto
-
-async function makeRequest() {
-  if (limiter.isAllowed()) {
-    return await fetch('https://example.com');
-  } else {
-    throw new Error('Rate limited');
-  }
-}
-```
-
-### 3.3 Sliding Window Counter
-
-**Como funciona:**
-- Divide tempo em janelas fixas
-- Conta requests em cada janela
-- Estima contagem atual baseado na janela anterior
-
-**Vantagens:**
-- Balance entre precisão e performance
-- Baixa memória
-- Simples
-
-**Desvantagens:**
-- Não é 100% preciso
-- Pode ter edge cases
-
-```javascript
-class SlidingWindowCounter {
-  constructor(windowSize, maxRequests) {
-    this.windowSize = windowSize;
-    this.maxRequests = maxRequests;
-    this.currentWindow = Math.floor(Date.now() / windowSize);
-    this.currentCount = 0;
-    this.previousCount = 0;
-  }
-
-  isAllowed() {
-    const now = Date.now();
-    const currentWindow = Math.floor(now / this.windowSize);
-
-    // Nova janela
-    if (currentWindow !== this.currentWindow) {
-      this.previousCount = this.currentCount;
-      this.currentCount = 0;
-      this.currentWindow = currentWindow;
-    }
-
-    // Calcular contagem estimada
-    const elapsed = now % this.windowSize;
-    const weight = elapsed / this.windowSize;
-    const estimatedCount = this.previousCount * (1 - weight) + this.currentCount;
-
-    if (estimatedCount < this.maxRequests) {
-      this.currentCount++;
-      return true;
-    }
-
-    return false;
-  }
-
-  getCount() {
-    const now = Date.now();
-    const currentWindow = Math.floor(now / this.windowSize);
-
-    if (currentWindow !== this.currentWindow) {
-      return 0;
-    }
-
-    return this.currentCount;
-  }
-}
-
-// Uso
-const limiter = new SlidingWindowCounter(60000, 100); // 100 requests por minuto
-
-async function makeRequest() {
-  if (limiter.isAllowed()) {
-    return await fetch('https://example.com');
-  } else {
-    throw new Error('Rate limited');
-  }
-}
-```
-
-### 3.4 Fixed Window
-
-**Como funciona:**
-- Divide tempo em janelas fixas
-- Conta requests em cada janela
-- Reseta contador no início da janela
-
-**Vantagens:**
-- Simples
-- Baixa memória
-- Rápido
-
-**Desvantagens:**
-- Edge cases no início/fim da janela
-- Pode permitir bursts
-
-```javascript
-class FixedWindow {
-  constructor(windowSize, maxRequests) {
-    this.windowSize = windowSize;
-    this.maxRequests = maxRequests;
-    this.windowStart = Date.now();
-    this.count = 0;
-  }
-
-  isAllowed() {
-    const now = Date.now();
-    
-    // Nova janela
-    if (now - this.windowStart >= this.windowSize) {
-      this.windowStart = now;
-      this.count = 0;
-    }
-
-    if (this.count < this.maxRequests) {
-      this.count++;
-      return true;
-    }
-
-    return false;
-  }
-
-  getCount() {
-    const now = Date.now();
-    if (now - this.windowStart >= this.windowSize) {
-      return 0;
-    }
-    return this.count;
-  }
-}
-
-// Uso
-const limiter = new FixedWindow(60000, 100); // 100 requests por minuto
-
-async function makeRequest() {
-  if (limiter.isAllowed()) {
-    return await fetch('https://example.com');
-  } else {
-    throw new Error('Rate limited');
-  }
-}
-```
-
-### 3.5 Leaky Bucket
-
-**Como funciona:**
-- Requests entram em uma fila
-- Requests saem a uma taxa fixa
-- Se fila cheia, request é rejeitado
-
-**Vantagens:**
-- Taxa suave e constante
-- Sem bursts
-
-**Desvantagens:**
-- Alta latência
-- Não permite bursts
-- Complexidade
-
-```javascript
-class LeakyBucket {
-  constructor(capacity, leakRate) {
-    this.capacity = capacity;
-    this.leakRate = leakRate; // requests por segundo
-    this.queue = [];
-    this.lastLeak = Date.now();
-  }
-
-  isAllowed() {
-    this.leak();
-
-    if (this.queue.length < this.capacity) {
-      this.queue.push(Date.now());
-      return true;
-    }
-
-    return false;
-  }
-
-  leak() {
-    const now = Date.now();
-    const elapsed = (now - this.lastLeak) / 1000;
-    const leakCount = Math.floor(elapsed * this.leakRate);
-
-    if (leakCount > 0) {
-      this.queue.splice(0, leakCount);
-      this.lastLeak = now;
-    }
-  }
-
-  getQueueSize() {
-    this.leak();
-    return this.queue.length;
-  }
-}
-
-// Uso
-const bucket = new LeakyBucket(10, 1); // 10 capacity, 1 por segundo
-
-async function makeRequest() {
-  if (bucket.isAllowed()) {
-    return await fetch('https://example.com');
-  } else {
-    throw new Error('Rate limited');
-  }
-}
-```
-
-### Tabela Comparativa de Algoritmos
-
-| Algoritmo | Precisão | Performance | Memória | Burst | Complexidade |
-|-----------|----------|-------------|---------|-------|--------------|
-| Token Bucket | Média | Alta | Baixa | Sim | Baixa |
-| Sliding Window Log | Alta | Baixa | Alta | Não | Média |
-| Sliding Window Counter | Média-Alta | Alta | Baixa | Parcial | Média |
-| Fixed Window | Baixa | Alta | Baixa | Sim | Baixa |
-| Leaky Bucket | Alta | Média | Média | Não | Média |
-
----
-
-## 4. Pacotes de Rate Limiting
-
-### 4.1 bottleneck
-
-**Versão:** 2.19.5  
-**Descrição:** Rate limiting avançado com clusters e jobs  
-**Última atualização:** 2023
-
-```javascript
-import Bottleneck from 'bottleneck';
-
-// Rate limiter básico
-const limiter = new Bottleneck({
-  minTime: 100,     // Mínimo 100ms entre requests
-  maxConcurrent: 5, // Máximo 5 requests simultâneos
-  reservoir: 10,    // 10 requests por período
-  reservoirRefreshAmount: 10,
-  reservoirRefreshInterval: 60000, // 1 minuto
-});
-
-// Usar com fetch
-async function makeRequest(url) {
-  return limiter.schedule(async () => {
-    const response = await fetch(url);
-    return response.json();
-  });
-}
-
-// Múltiplos limiters (clusters)
-const cluster = new Bottleneck.Cluster({
-  datastore: 'redis',
-  redis: { host: 'localhost', port: 6379 },
-});
-
-const limiter1 = cluster.cluster('api1');
-const limiter2 = cluster.cluster('api2');
-
-// Rate limits diferentes por endpoint
-const apiLimiter = new Bottleneck({
-  reservoir: 100,
-  reservoirRefreshAmount: 100,
-  reservoirRefreshInterval: 60000,
-});
-
-const searchLimiter = new Bottleneck({
-  minTime: 500,
-  maxConcurrent: 2,
-});
-
-// Encadear limiters
-const combinedLimiter = Bottleneck.chain(apiLimiter, searchLimiter);
-```
-
-### 4.2 p-throttle
-
-**Versão:** 6.2.0  
-**Descrição:** Throttling de funções com suporte a ESM  
-**Última atualização:** 2023
-
-```javascript
-import pThrottle from 'p-throttle';
-
-// Limitar a 10 chamadas por segundo
-const throttle = pThrottle({
-  limit: 10,
-  interval: 1000,
-  strict: true,
-});
-
-const throttledFetch = throttle(async (url) => {
-  const response = await fetch(url);
-  return response.json();
-});
-
-// Usar
-for (const url of urls) {
-  const data = await throttledFetch(url);
-  console.log(data);
-}
-
-// Throttled function com abort
-const controller = new AbortController();
-const throttledFetchWithAbort = throttle(async (url) => {
-  const response = await fetch(url, { signal: controller.signal });
-  return response.json();
-});
-```
-
-### 4.3 p-limit
-
-**Versão:** 7.3.0  
-**Descrição:** Limitação de concorrência  
-**Última atualização:** 2023
-
-```javascript
-import pLimit from 'p-limit';
-
-// Limitar a 5 concorrências
-const limit = pLimit(5);
-
-// Criar tasks com limite
-const tasks = urls.map(url => {
-  return limit(async () => {
-    const response = await fetch(url);
-    return response.json();
-  });
-});
-
-const results = await Promise.all(tasks);
-
-// Verificar estado
-console.log(limit.activeCount);  // Requests ativos
-console.log(limit.pendingCount); // Requests pendentes
-
-// Limitar por domínio
-const domainLimits = new Map();
-
-function getLimiterForDomain(domain) {
-  if (!domainLimits.has(domain)) {
-    domainLimits.set(domain, pLimit(5));
-  }
-  return domainLimits.get(domain);
-}
-
-// Usar
-const limiter = getLimiterForDomain('example.com');
-const result = await limiter(async () => {
-  return await fetch('https://example.com/api');
-});
-```
-
-### 4.4 p-queue
-
-**Versão:** 9.2.0  
-**Descrição:** Fila de tarefas com prioridade  
-**Última atualização:** 2024
-
-```javascript
-import PQueue from 'p-queue';
-
-// Fila com limite de concorrência
-const queue = new PQueue({
-  concurrency: 5,
-  intervalCap: 10,
-  interval: 1000,
-});
-
-// Adicionar tarefas com prioridade
-queue.add(async () => {
-  return await fetch('https://example.com/low');
-}, { priority: 1 });
-
-queue.add(async () => {
-  return await fetch('https://example.com/high');
-}, { priority: 10 });
-
-// Verificar estado
-console.log(queue.size);      // Tamanho da fila
-console.log(queue.pending);   // Tarefas pendentes
-console.log(queue.isPaused);  // Se está pausada
-
-// Pausar/Retomar
-queue.pause();
-queue.start();
-
-// Adicionar com timeout
-queue.add(async () => {
-  return await fetch('https://example.com');
-}, { 
-  timeout: 5000,
-  signal: AbortSignal.timeout(5000),
-});
-```
-
-### 4.5 limiter
-
-**Versão:** 3.0.0  
-**Descrição:** Rate limiting simples baseado em Redis  
-**Última atualização:** 2022
-
-```javascript
-import { RateLimiterRedis } from 'limiter';
-import Redis from 'ioredis';
-
-const redis = new Redis();
-
-const limiter = new RateLimiterRedis({
-  storeClient: redis,
-  keyPrefix: 'rl',
-  points: 100,        // 100 requests
-  duration: 60,       // por 60 segundos
-  blockDuration: 60,  // bloquear por 60 segundos se exceder
-});
-
-// Consumir pontos
-try {
-  await limiter.consume('user123');
-  const response = await fetch('https://example.com');
-  return response.json();
-} catch (rateLimiterRes) {
-  const retryAfter = Math.ceil(rateLimiterRes.msBeforeNext / 1000);
-  console.log(`Rate limited. Retry after ${retryAfter}s`);
-  throw new Error(`Rate limited. Retry after ${retryAfter}s`);
-}
-
-// Verificar pontos restantes
-const resRateLimiter = await limiter.get('user123');
-console.log(`Points remaining: ${resRateLimiter.remainingPoints}`);
-```
-
-### 4.6 rate-limiter-flexible
-
-**Versão:** 11.1.0  
-**Descrição:** Rate limiting flexível e robusto  
-**Última atualização:** 2024
-
-```javascript
-import { RateLimiterRedis, RateLimiterMemory } from 'rate-limiter-flexible';
-
-// Rate limiter em memória
-const rateLimiter = new RateLimiterMemory({
-  points: 100,        // 100 requests
-  duration: 60,       // por 60 segundos
-});
-
-// Rate limiter com Redis
-const redisRateLimiter = new RateLimiterRedis({
-  points: 100,
-  duration: 60,
-  storeClient: redisClient,
-  keyPrefix: 'rl',
-});
-
-// Consumir pontos
-try {
-  const res = await rateLimiter.consume('user123');
-  console.log(`Points remaining: ${res.remainingPoints}`);
-  console.log(`Retry after: ${res.msBeforeNext}ms`);
-} catch (rejRes) {
-  console.log(`Rate limited. Retry after ${rejRes.msBeforeNext}ms`);
-}
-
-// Bloquear IP após múltiplas falhas
-const rateLimiterBlock = new RateLimiterMemory({
-  points: 1,
-  duration: 1,
-  blockDuration: 3600, // Bloquear por 1 hora
-});
-
-// Rate limiting com sliding window
-const slidingWindowLimiter = new RateLimiterMemory({
-  points: 100,
-  duration: 60,
-  execEvenly: true,       // Executar均匀mente
-  execEvenlyMinDelayMs: 100, // Mínimo 100ms entre requests
-});
-```
-
----
-
-## 5. Rate Limiting por Domínio
-
-### 5.1 Implementação com Map
-
-```javascript
-import { RateLimiterMemory } from 'rate-limiter-flexible';
-
-class DomainRateLimiter {
-  constructor(defaults = {}) {
-    this.limiters = new Map();
-    this.defaults = {
-      points: defaults.points || 100,
-      duration: defaults.duration || 60,
-      blockDuration: defaults.blockDuration || 0,
-    };
-  }
-
-  getLimiter(domain) {
-    if (!this.limiters.has(domain)) {
-      this.limiters.set(domain, new RateLimiterMemory({
-        points: this.defaults.points,
-        duration: this.defaults.duration,
-        blockDuration: this.defaults.blockDuration,
-      }));
-    }
-    return this.limiters.get(domain);
-  }
-
-  async consume(domain, key = 'default', points = 1) {
-    const limiter = this.getLimiter(domain);
-    try {
-      const res = await limiter.consume(key, points);
-      return { allowed: true, remaining: res.remainingPoints };
-    } catch (rejRes) {
-      return { 
-        allowed: false, 
-        retryAfter: Math.ceil(rejRes.msBeforeNext / 1000),
-        remaining: 0,
-      };
-    }
-  }
-
-  async reset(domain, key = 'default') {
-    const limiter = this.getLimiter(domain);
-    await limiter.delete(key);
-  }
-}
-
-// Uso
-const limiter = new DomainRateLimiter({
-  points: 100,
-  duration: 60,
-});
-
-async function fetchWithRateLimit(url) {
-  const domain = new URL(url).hostname;
-  const result = await limiter.consume(domain);
-
-  if (!result.allowed) {
-    console.log(`Rate limited by ${domain}. Retry after ${result.retryAfter}s`);
-    throw new Error(`Rate limited. Retry after ${result.retryAfter}s`);
-  }
-
-  return await fetch(url);
-}
-```
-
-### 5.2 Implementação com Crawlee
-
-```javascript
-import { PlaywrightCrawler } from 'crawlee';
-
-class CrawleeDomainRateLimiter {
-  constructor(limits = {}) {
-    this.limits = limits;
-    this.domainRequests = new Map();
-    this.domainWindows = new Map();
-  }
-
-  getLimitForDomain(domain) {
-    return this.limits[domain] || { requestsPerMinute: 60 };
-  }
-
-  async checkRateLimit(domain) {
-    const limit = this.getLimitForDomain(domain);
-    const now = Date.now();
-    const windowStart = now - 60000;
-
-    if (!this.domainWindows.has(domain)) {
-      this.domainWindows.set(domain, []);
-    }
-
-    const requests = this.domainWindows.get(domain)
-      .filter(time => time > windowStart);
-
-    this.domainWindows.set(domain, requests);
-
-    if (requests.length >= limit.requestsPerMinute) {
-      const oldestRequest = requests[0];
-      const retryAfter = Math.ceil((oldestRequest + 60000 - now) / 1000);
-      return { allowed: false, retryAfter };
-    }
-
-    requests.push(now);
-    return { allowed: true, remaining: limit.requestsPerMinute - requests.length };
-  }
-}
-
-// Uso com Crawlee
-const rateLimiter = new CrawleeDomainRateLimiter({
-  'example.com': { requestsPerMinute: 30 },
-  'api.example.com': { requestsPerMinute: 10 },
-  'default': { requestsPerMinute: 60 },
-});
-
-const crawler = new PlaywrightCrawler({
-  requestHandler: async ({ request, page }) => {
-    const domain = new URL(request.url).hostname;
-    const rateCheck = await rateLimiter.checkRateLimit(domain);
-
-    if (!rateCheck.allowed) {
-      console.log(`Rate limited. Retry after ${rateCheck.retryAfter}s`);
-      await page.waitForTimeout(rateCheck.retryAfter * 1000);
-    }
-
-    await page.goto(request.url);
-    return { title: await page.title() };
-  },
-});
-```
-
-### 5.3 Configuração por Endpoint
-
-```javascript
-import { RateLimiterMemory } from 'rate-limiter-flexible';
-
-const endpointLimits = {
-  'api.example.com': {
-    '/search': { points: 10, duration: 60 },
-    '/users': { points: 100, duration: 60 },
-    '/posts': { points: 50, duration: 60 },
-  },
-  'cdn.example.com': {
-    '/images': { points: 1000, duration: 60 },
-    '/videos': { points: 100, duration: 60 },
-  },
-};
-
-class EndpointRateLimiter {
-  constructor(limits) {
-    this.limits = limits;
-    this.limiters = new Map();
-  }
-
-  getLimiter(domain, path) {
-    const key = `${domain}:${path}`;
-    if (!this.limiters.has(key)) {
-      const limit = this.limits[domain]?.[path] || { points: 60, duration: 60 };
-      this.limiters.set(key, new RateLimiterMemory(limit));
-    }
-    return this.limiters.get(key);
-  }
-
-  async consume(domain, path) {
-    const limiter = this.getLimiter(domain, path);
-    try {
-      const res = await limiter.consume();
-      return { allowed: true, remaining: res.remainingPoints };
-    } catch (rejRes) {
-      return { 
-        allowed: false, 
-        retryAfter: Math.ceil(rejRes.msBeforeNext / 1000),
-      };
-    }
-  }
-}
-
-// Uso
-const limiter = new EndpointRateLimiter(endpointLimits);
-
-async function apiCall(url) {
-  const urlObj = new URL(url);
-  const result = await limiter.consume(urlObj.hostname, urlObj.pathname);
-  
-  if (!result.allowed) {
-    throw new Error(`Rate limited. Retry after ${result.retryAfter}s`);
-  }
-  
-  return await fetch(url);
-}
-```
-
----
-
-## 6. Status Codes para Retry
-
-### Status Codes para RETRY
-
-| Status | Descrição | Estratégia |
-|--------|-----------|------------|
-| **429** | Too Many Requests | Retry com Retry-After |
-| **500** | Internal Server Error | Retry com backoff |
-| **502** | Bad Gateway | Retry com backoff |
-| **503** | Service Unavailable | Retry com Retry-After |
-| **504** | Gateway Timeout | Retry com backoff |
-| **408** | Request Timeout | Retry com backoff |
-| **409** | Conflict | Retry (pode ser temporário) |
-| **520-530** | Cloudflare Errors | Retry com backoff |
-
-### Status Codes NÃO Retry
-
-| Status | Descrição | Ação |
-|--------|-----------|------|
-| **400** | Bad Request | Corrigir request |
-| **401** | Unauthorized | Autenticar |
-| **403** | Forbidden | Verificar permissões |
-| **404** | Not Found | Verificar URL |
-| **410** | Gone | Não existe mais |
-| **422** | Unprocessable Entity | Corrigir dados |
-| **451** | Unavailable For Legal Reasons | Não retry |
-| **407** | Proxy Authentication Required | Autenticar proxy |
-| **426** | Upgrade Required | Atualizar protocolo |
-
-### Implementação de Decisão de Retry
-
-```javascript
-function shouldRetry(error) {
-  // Retry em erros de rede
-  if (error.code === 'ECONNRESET' || 
-      error.code === 'ECONNREFUSED' ||
-      error.code === 'ETIMEDOUT' ||
-      error.code === 'ENOTFOUND') {
-    return true;
-  }
-
-  // Retry em status codes específicos
-  if (error.status) {
-    const retryableStatuses = [429, 500, 502, 503, 504, 408, 409];
-    if (retryableStatuses.includes(error.status)) {
-      return true;
-    }
-  }
-
-  // Não retry em erros de autenticação
-  if (error.status === 401 || error.status === 403) {
-    return false;
-  }
-
-  // Não retry em erros de validação
-  if (error.status === 400 || error.status === 422) {
-    return false;
-  }
-
-  return false;
-}
-
-// Usar com retry
-import pRetry from 'p-retry';
-
-const result = await pRetry(async () => {
-  const response = await fetch('https://example.com');
-  
-  if (!response.ok) {
-    const error = new Error(`HTTP ${response.status}`);
-    error.status = response.status;
-    throw error;
-  }
-  
-  return response.json();
-}, {
-  retries: 5,
-  onFailedAttempt: async (error) => {
-    if (!shouldRetry(error)) {
-      throw new pRetry.AbortError(error);
-    }
-  },
-});
-```
-
----
-
-## 7. Respeitando Retry-After
-
-### Implementação Básica
-
-```javascript
-import pRetry from 'p-retry';
-
-async function fetchWithRetryAfter(url) {
-  return pRetry(async (attempt) => {
-    const response = await fetch(url);
-
-    if (response.status === 429) {
-      const retryAfter = response.headers.get('Retry-After');
-      
-      if (retryAfter) {
-        // Retry-After pode ser:
-        // 1. Número de segundos: "120"
-        // 2. HTTP-date: "Wed, 21 Oct 2015 07:28:00 GMT"
-        let delay;
-
-        if (isNaN(retryAfter)) {
-          // É uma data HTTP
-          const retryDate = new Date(retryAfter);
-          delay = retryDate.getTime() - Date.now();
-        } else {
-          // É um número de segundos
-          delay = parseInt(retryAfter) * 1000;
-        }
-
-        console.log(`Rate limited. Waiting ${delay}ms`);
-        await new Promise(resolve => setTimeout(resolve, delay));
-      }
-      
-      throw new Error(`Rate limited (429)`);
-    }
-
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-
-    return response.json();
-  }, {
-    retries: 5,
-    minTimeout: 1000,
-    maxTimeout: 60000,
-  });
-}
-```
-
-### Implementação Avançada com Crawlee
-
-```javascript
-import { PlaywrightCrawler } from 'crawlee';
-
-class RetryAfterHandler {
-  constructor() {
-    this.retryAfterCache = new Map();
-  }
-
-  async handleRetryAfter(request, response) {
-    const retryAfter = response.headers.get('Retry-After');
-    
-    if (retryAfter) {
-      let delay;
-      
-      if (isNaN(retryAfter)) {
-        const retryDate = new Date(retryAfter);
-        delay = Math.max(0, retryDate.getTime() - Date.now());
-      } else {
-        delay = parseInt(retryAfter) * 1000;
-      }
-
-      // Adicionar margem de segurança (10%)
-      delay = Math.ceil(delay * 1.1);
-
-      this.retryAfterCache.set(request.url, {
-        delay,
-        timestamp: Date.now(),
-      });
-
-      return delay;
-    }
-
-    return null;
-  }
-
-  getDelay(url) {
-    const cached = this.retryAfterCache.get(url);
-    if (cached && Date.now() - cached.timestamp < cached.delay) {
-      return cached.delay - (Date.now() - cached.timestamp);
-    }
-    return null;
-  }
-}
-
-// Usar com Crawlee
-const retryHandler = new RetryAfterHandler();
-
-const crawler = new PlaywrightCrawler({
-  requestHandler: async ({ request, page, response }) => {
-    // Verificar Retry-After
-    const delay = await retryHandler.handleRetryAfter(request, response);
-    
-    if (delay) {
-      console.log(`Waiting ${delay}ms for Retry-After`);
-      await page.waitForTimeout(delay);
-    }
-
-    await page.goto(request.url);
-    return { title: await page.title() };
-  },
-});
-```
-
-### Retry-After com Múltiplos Headers
-
-```javascript
-async function parseRetryAfter(response) {
-  const retryAfter = response.headers.get('Retry-After');
-  const xRetryAfter = response.headers.get('X-Retry-After');
-  const rateLimitReset = response.headers.get('X-Rate-Limit-Reset');
-  const rateLimitRemaining = response.headers.get('X-Rate-Limit-Remaining');
-
-  // Prioridade: Retry-After > X-Retry-After > X-Rate-Limit-Reset
-  if (retryAfter) {
-    return parseRetryHeaderValue(retryAfter);
-  }
-
-  if (xRetryAfter) {
-    return parseRetryHeaderValue(xRetryAfter);
-  }
-
-  if (rateLimitReset) {
-    const resetTime = parseInt(rateLimitReset) * 1000;
-    return Math.max(0, resetTime - Date.now());
-  }
-
-  return null;
-}
-
-function parseRetryHeaderValue(value) {
-  if (isNaN(value)) {
-    // HTTP-date
-    const retryDate = new Date(value);
-    return Math.max(0, retryDate.getTime() - Date.now());
-  }
-  // Seconds
-  return parseInt(value) * 1000;
-}
-```
-
----
-
-## 8. Retry com Proxy Rotation
-
-### Padrão Básico
-
-```javascript
-import pRetry from 'p-retry';
-
-class RetryWithProxyRotation {
-  constructor(proxies) {
-    this.proxies = proxies;
-    this.currentIndex = 0;
-  }
-
-  getNextProxy() {
-    const proxy = this.proxies[this.currentIndex % this.proxies.length];
-    this.currentIndex++;
-    return proxy;
-  }
-
-  async fetchWithRetry(url, options = {}) {
-    return pRetry(async (attempt) => {
-      const proxy = this.getNextProxy();
-      console.log(`Attempt ${attempt} using proxy ${proxy}`);
-
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), options.timeout || 10000);
-
-      try {
-        const response = await fetch(url, {
-          ...options,
-          signal: controller.signal,
-          dispatcher: this.createAgent(proxy),
-        });
-
-        clearTimeout(timeoutId);
-
-        if (!response.ok) {
-          const error = new Error(`HTTP ${response.status}`);
-          error.status = response.status;
-          throw error;
-        }
-
-        return response.json();
-      } catch (error) {
-        clearTimeout(timeoutId);
-        throw error;
-      }
-    }, {
-      retries: options.retries || 3,
-      minTimeout: options.minTimeout || 1000,
-      maxTimeout: options.maxTimeout || 10000,
-      onFailedAttempt: async (error) => {
-        console.log(`Attempt ${error.attemptNumber} failed: ${error.message}`);
-        if (error.retriesLeft === 0) {
-          throw new pRetry.AbortError(error);
-        }
-      },
-    });
-  }
-
-  createAgent(proxy) {
-    if (proxy.startsWith('socks')) {
-      const { SocksProxyAgent } = require('socks-proxy-agent');
-      return new SocksProxyAgent(proxy);
-    }
-    const { HttpsProxyAgent } = require('https-proxy-agent');
-    return new HttpsProxyAgent(proxy);
-  }
-}
-
-// Uso
-const fetcher = new RetryWithProxyRotation([
-  'http://proxy1.com:8080',
-  'http://proxy2.com:8080',
-  'http://proxy3.com:8080',
-]);
-
-const result = await fetcher.fetchWithRetry('https://example.com/api', {
-  retries: 5,
-  timeout: 10000,
-});
-```
-
-### Padrão com Status Codes
-
-```javascript
-import pRetry from 'p-retry';
-
-class SmartRetryWithProxy {
-  constructor(proxies, options = {}) {
-    this.proxies = proxies;
-    this.currentIndex = 0;
-    this.retryableStatuses = options.retryableStatuses || [429, 500, 502, 503, 504];
-    this.proxyFailureThreshold = options.proxyFailureThreshold || 3;
-    this.proxyFailures = new Map();
-  }
-
-  getNextProxy() {
-    // Filtrar proxies com muitas falhas
-    const availableProxies = this.proxies.filter(proxy => {
-      const failures = this.proxyFailures.get(proxy) || 0;
-      return failures < this.proxyFailureThreshold;
-    });
-
-    if (availableProxies.length === 0) {
-      // Resetar contadores de falha
-      this.proxyFailures.clear();
-      return this.proxies[0];
-    }
-
-    const proxy = availableProxies[this.currentIndex % availableProxies.length];
-    this.currentIndex++;
-    return proxy;
-  }
-
-  reportProxyFailure(proxy) {
-    const failures = this.proxyFailures.get(proxy) || 0;
-    this.proxyFailures.set(proxy, failures + 1);
-  }
-
-  async fetchWithRetry(url, options = {}) {
-    return pRetry(async (attempt) => {
-      const proxy = this.getNextProxy();
-      console.log(`Attempt ${attempt} using proxy ${proxy}`);
-
-      try {
-        const response = await fetch(url, {
-          ...options,
-          dispatcher: this.createAgent(proxy),
-        });
-
-        if (!response.ok) {
-          const error = new Error(`HTTP ${response.status}`);
-          error.status = response.status;
-          error.proxy = proxy;
-          throw error;
-        }
-
-        return response.json();
-      } catch (error) {
-        if (error.status && !this.retryableStatuses.includes(error.status)) {
-          throw new pRetry.AbortError(error);
-        }
-        
-        if (error.proxy) {
-          this.reportProxyFailure(error.proxy);
-        }
-        
-        throw error;
-      }
-    }, {
-      retries: options.retries || 5,
-      minTimeout: options.minTimeout || 1000,
-      maxTimeout: options.maxTimeout || 30000,
-      randomize: true,
-      onFailedAttempt: async (error) => {
-        console.log(`Attempt ${error.attemptNumber} failed: ${error.message}`);
-      },
-    });
-  }
-
-  createAgent(proxy) {
-    if (proxy.startsWith('socks')) {
-      const { SocksProxyAgent } = require('socks-proxy-agent');
-      return new SocksProxyAgent(proxy);
-    }
-    const { HttpsProxyAgent } = require('https-proxy-agent');
-    return new HttpsProxyAgent(proxy);
-  }
-}
-
-// Uso
-const fetcher = new SmartRetryWithProxy([
-  'http://proxy1.com:8080',
-  'http://proxy2.com:8080',
-  'socks5://proxy3.com:1080',
-], {
-  retryableStatuses: [429, 500, 502, 503, 504],
-  proxyFailureThreshold: 3,
-});
-
-const result = await fetcher.fetchWithRetry('https://example.com/api');
-```
-
-### Padrão com Crawlee
-
-```javascript
-import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';
-
-class CrawleeRetryWithProxy {
-  constructor(proxies) {
-    this.proxies = proxies;
-    this.currentIndex = 0;
-    this.proxyFailures = new Map();
-  }
-
-  getNextProxy() {
-    const availableProxies = this.proxies.filter(proxy => {
-      const failures = this.proxyFailures.get(proxy) || 0;
-      return failures < 3;
-    });
-
-    if (availableProxies.length === 0) {
-      this.proxyFailures.clear();
-      return this.proxies[0];
-    }
-
-    const proxy = availableProxies[this.currentIndex % availableProxies.length];
-    this.currentIndex++;
-    return proxy;
-  }
-
-  reportFailure(proxy) {
-    const failures = this.proxyFailures.get(proxy) || 0;
-    this.proxyFailures.set(proxy, failures + 1);
-  }
-
-  getCrawlerOptions() {
-    return {
-      proxyConfiguration: new ProxyConfiguration({
-        newUrlFunction: () => this.getNextProxy(),
-      }),
-      retryOnBlocked: true,
-      maxRequestRetries: 5,
-      requestHandlerTimeoutSecs: 30,
-      requestHandler: async ({ request, page, proxyInfo }) => {
-        try {
-          await page.goto(request.url, { timeout: 30000 });
-          const title = await page.title();
-          return { url: request.url, title };
-        } catch (error) {
-          this.reportFailure(proxyInfo.url);
-          throw error;
-        }
-      },
-    };
-  }
-}
-
-// Uso
-const retryProxy = new CrawleeRetryWithProxy([
-  'http://proxy1.com:8080',
-  'http://proxy2.com:8080',
-  'socks5://proxy3.com:1080',
-]);
-
-const crawler = new PlaywrightCrawler(retryProxy.getCrawlerOptions());
-await crawler.run(['https://example.com']);
-```
-
----
-
-## 9. Exemplos Completos
-
-### 9.1 Exemplo Completo: Retry com Rate Limiting
-
-```javascript
-import pRetry from 'p-retry';
-import { RateLimiterMemory } from 'rate-limiter-flexible';
-
-class ResilientFetcher {
-  constructor(options = {}) {
-    this.rateLimiter = new RateLimiterMemory({
-      points: options.rateLimit?.points || 10,
-      duration: options.rateLimit?.duration || 1,
-    });
-
-    this.retryOptions = {
-      retries: options.retries || 5,
-      minTimeout: options.minTimeout || 1000,
-      maxTimeout: options.maxTimeout || 30000,
-      randomize: options.randomize ?? true,
-    };
-
-    this.retryableStatuses = options.retryableStatuses || [429, 500, 502, 503, 504];
-  }
-
-  async fetch(url, options = {}) {
-    // Rate limiting
-    const domain = new URL(url).hostname;
-    try {
-      await this.rateLimiter.consume(domain);
-    } catch (rejRes) {
-      const retryAfter = Math.ceil(rejRes.msBeforeNext / 1000);
-      console.log(`Rate limited by ${domain}. Waiting ${retryAfter}s`);
-      await this.sleep(retryAfter * 1000);
-    }
-
-    // Retry logic
-    return pRetry(async (attempt) => {
-      console.log(`Attempt ${attempt} for ${url}`);
-
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), options.timeout || 10000);
-
-      try {
-        const response = await fetch(url, {
-          ...options,
-          signal: controller.signal,
-        });
-
-        clearTimeout(timeoutId);
-
-        // Tratar Retry-After
-        if (response.status === 429) {
-          const retryAfter = response.headers.get('Retry-After');
-          if (retryAfter) {
-            const delay = this.parseRetryAfter(retryAfter);
-            console.log(`Retry-After: ${delay}ms`);
-            await this.sleep(delay);
-          }
-          throw new Error(`Rate limited (429)`);
-        }
-
-        if (!response.ok) {
-          const error = new Error(`HTTP ${response.status}`);
-          error.status = response.status;
-          throw error;
-        }
-
-        return response.json();
-      } catch (error) {
-        clearTimeout(timeoutId);
-
-        // Não retry em erros não retryable
-        if (error.status && !this.retryableStatuses.includes(error.status)) {
-          throw new pRetry.AbortError(error);
-        }
-
-        throw error;
-      }
-    }, {
-      ...this.retryOptions,
-      onFailedAttempt: async (error) => {
-        console.log(`Attempt ${error.attemptNumber} failed: ${error.message}`);
-        console.log(`Retries left: ${error.retriesLeft}`);
-      },
-    });
-  }
-
-  parseRetryAfter(value) {
-    if (isNaN(value)) {
-      const retryDate = new Date(value);
-      return Math.max(0, retryDate.getTime() - Date.now());
-    }
-    return parseInt(value) * 1000;
-  }
-
-  sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}
-
-// Uso
-const fetcher = new ResilientFetcher({
-  rateLimit: { points: 10, duration: 1 },
-  retries: 5,
-  minTimeout: 1000,
-  maxTimeout: 30000,
-  retryableStatuses: [429, 500, 502, 503, 504],
-});
-
-const result = await fetcher.fetch('https://api.example.com/data');
-```
-
-### 9.2 Exemplo Completo: Crawlee com Rate Limiting e Retry
-
-```javascript
-import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';
-import { RateLimiterMemory } from 'rate-limiter-flexible';
-
-class ProductionScraper {
-  constructor(options = {}) {
-    this.proxies = options.proxies || [];
-    this.proxyIndex = 0;
-    this.proxyFailures = new Map();
-    this.rateLimiters = new Map();
-    this.defaultRateLimit = options.rateLimit || { points: 60, duration: 60 };
-  }
-
-  getProxy() {
-    const available = this.proxies.filter(p => 
-      (this.proxyFailures.get(p) || 0) < 3
-    );
-
-    if (available.length === 0) {
-      this.proxyFailures.clear();
-      return this.proxies[0];
-    }
-
-    const proxy = available[this.proxyIndex % available.length];
-    this.proxyIndex++;
-    return proxy;
-  }
-
-  reportProxyFailure(proxy) {
-    const failures = this.proxyFailures.get(proxy) || 0;
-    this.proxyFailures.set(proxy, failures + 1);
-  }
-
-  getRateLimiter(domain) {
-    if (!this.rateLimiters.has(domain)) {
-      this.rateLimiters.set(domain, new RateLimiterMemory(this.defaultRateLimit));
-    }
-    return this.rateLimiters.get(domain);
-  }
-
-  async checkRateLimit(domain) {
-    const limiter = this.getRateLimiter(domain);
-    try {
-      await limiter.consume();
-      return { allowed: true };
-    } catch (rejRes) {
-      return {
-        allowed: false,
-        retryAfter: Math.ceil(rejRes.msBeforeNext / 1000),
-      };
-    }
-  }
-
-  getCrawlerOptions() {
-    return {
-      proxyConfiguration: new ProxyConfiguration({
-        newUrlFunction: () => this.getProxy(),
-      }),
-      retryOnBlocked: true,
-      maxRequestRetries: 5,
-      requestHandlerTimeoutSecs: 30,
-      requestHandler: async ({ request, page, proxyInfo }) => {
-        const domain = new URL(request.url).hostname;
-
-        // Rate limiting
-        const rateCheck = await this.checkRateLimit(domain);
-        if (!rateCheck.allowed) {
-          console.log(`Rate limited. Waiting ${rateCheck.retryAfter}s`);
-          await page.waitForTimeout(rateCheck.retryAfter * 1000);
-        }
-
-        try {
-          await page.goto(request.url, { timeout: 30000 });
-          
-          // Extrair dados
-          const title = await page.title();
-          const content = await page.textContent('body');
-          
-          return { url: request.url, title, content };
-        } catch (error) {
-          if (proxyInfo?.url) {
-            this.reportProxyFailure(proxyInfo.url);
-          }
-          throw error;
-        }
-      },
-    };
-  }
-
-  async scrape(urls) {
-    const crawler = new PlaywrightCrawler(this.getCrawlerOptions());
-    await crawler.run(urls);
-    
-    // Estatísticas
-    console.log('Scraping completed');
-    console.log('Proxy failures:', Object.fromEntries(this.proxyFailures));
-  }
-}
-
-// Uso
-const scraper = new ProductionScraper({
-  proxies: [
-    'http://proxy1.com:8080',
-    'http://proxy2.com:8080',
-    'socks5://proxy3.com:1080',
-  ],
-  rateLimit: { points: 60, duration: 60 },
-});
-
-await scraper.scrape([
-  'https://example.com/page1',
-  'https://example.com/page2',
-  'https://example.com/page3',
-]);
-```
-
-### 9.3 Exemplo Completo: Sistema de Retry com Circuit Breaker
-
-```javascript
-import pRetry from 'p-retry';
-
-class CircuitBreaker {
-  constructor(options = {}) {
-    this.failureThreshold = options.failureThreshold || 5;
-    this.resetTimeout = options.resetTimeout || 60000;
-    this.state = 'CLOSED';
-    this.failureCount = 0;
-    this.lastFailureTime = null;
-  }
-
-  async execute(fn) {
-    if (this.state === 'OPEN') {
-      if (Date.now() - this.lastFailureTime >= this.resetTimeout) {
-        this.state = 'HALF_OPEN';
-      } else {
-        throw new Error('Circuit breaker is OPEN');
-      }
-    }
-
-    try {
-      const result = await fn();
-      this.onSuccess();
-      return result;
-    } catch (error) {
-      this.onFailure();
-      throw error;
-    }
-  }
-
-  onSuccess() {
-    this.failureCount = 0;
-    this.state = 'CLOSED';
-  }
-
-  onFailure() {
-    this.failureCount++;
-    this.lastFailureTime = Date.now();
-
-    if (this.failureCount >= this.failureThreshold) {
-      this.state = 'OPEN';
-    }
-  }
-
-  getState() {
-    return {
-      state: this.state,
-      failureCount: this.failureCount,
-      lastFailureTime: this.lastFailureTime,
-    };
-  }
-}
-
-class ResilientFetcher {
-  constructor(options = {}) {
-    this.circuitBreaker = new CircuitBreaker({
-      failureThreshold: options.failureThreshold || 5,
-      resetTimeout: options.resetTimeout || 60000,
-    });
-
-    this.retryOptions = {
-      retries: options.retries || 3,
-      minTimeout: options.minTimeout || 1000,
-      maxTimeout: options.maxTimeout || 10000,
-    };
-  }
-
-  async fetch(url, options = {}) {
-    return this.circuitBreaker.execute(async () => {
-      return pRetry(async (attempt) => {
-        console.log(`Attempt ${attempt} for ${url}`);
-
-        const response = await fetch(url, options);
-
-        if (!response.ok) {
-          const error = new Error(`HTTP ${response.status}`);
-          error.status = response.status;
-          throw error;
-        }
-
-        return response.json();
-      }, this.retryOptions);
-    });
-  }
-
-  getState() {
-    return this.circuitBreaker.getState();
-  }
-}
-
-// Uso
-const fetcher = new ResilientFetcher({
-  failureThreshold: 5,
-  resetTimeout: 60000,
-  retries: 3,
-});
-
-try {
-  const result = await fetcher.fetch('https://api.example.com/data');
-  console.log('Success:', result);
-} catch (error) {
-  console.log('Failed:', error.message);
-  console.log('Circuit breaker state:', fetcher.getState());
-}
-```
-
----
-
-## Referências
-
-1. p-retry - https://github.com/sindresorhus/p-retry
-2. async-retry - https://github.com/vercel/async-retry
-3. retry - https://github.com/STRML/retry
-4. exponential-backoff - https://github.com/coveo/exponential-backoff
-5. bottleneck - https://github.com/SGrondin/bottleneck
-6. p-throttle - https://github.com/sindresorhus/p-throttle
-7. p-limit - https://github.com/sindresorhus/p-limit
-8. p-queue - https://github.com/sindresorhus/p-queue
-9. rate-limiter-flexible - https://github.com/animir/node-rate-limiter-flexible
-10. Crawlee Rate Limiting - https://crawlee.dev/docs/guides/avoid-blocking