Khi xây dựng ứng dụng AI trong môi trường production, việc xử lý gián đoạn stream output là yếu tố sống còn quyết định trải nghiệm người dùng. Bài viết này cung cấp giải pháp toàn diện giúp bạn xử lý lỗi stream một cách graceful, triển khai retry mechanism thông minh và đảm bảo 断点续传 (resume from breakpoint) hoạt động 100%.

So Sánh HolySheep vs API Chính Thức vs Đối Thủ

Tiêu chí HolySheep AI API Chính Thức Đối thủ A Đối thủ B
Giá GPT-4.1 $8/MTok $60/MTok $45/MTok $50/MTok
Độ trễ trung bình <50ms 200-500ms 150-300ms 180-400ms
Tỷ giá ¥1 = $1 (85%+ tiết kiệm) Giá quốc tế Giá quốc tế Giá quốc tế
Thanh toán WeChat/Alipay, Credit card Chỉ Credit card quốc tế Credit card quốc tế Credit card quốc tế
Tín dụng miễn phí Có khi đăng ký $5 trial Không $3 trial
Stream stability 99.9% uptime 99.5% 98% 97%
Hỗ trợ retry tự động Tích hợp sẵn Cần tự implement Cần tự implement Cơ bản

Kết Luận Trước - Đừng Để Stream Interruption Phá Vỡ Ứng Dụng Của Bạn

Nếu bạn đang xây dựng ứng dụng cần xử lý GPT-5 stream output, câu trả lời ngắn gọn là: HolySheep AI là lựa chọn tối ưu với độ trễ dưới 50ms, retry mechanism tích hợp sẵn, và chi phí thấp hơn 85% so với API chính thức. Phần còn lại của bài viết sẽ hướng dẫn bạn implement chi tiết.

Phù Hợp / Không Phù Hợp Với Ai

✅ Nên sử dụng HolySheep khi:

❌ Có thể không phù hợp khi:

Giá và ROI - Tính Toán Chi Phí Thực Tế

Model HolySheep API Chính Thức Tiết kiệm
GPT-4.1 $8/MTok $60/MTok 86.7%
Claude Sonnet 4.5 $15/MTok $75/MTok 80%
Gemini 2.5 Flash $2.50/MTok $10/MTok 75%
DeepSeek V3.2 $0.42/MTok $2/MTok 79%

Ví dụ ROI: Ứng dụng xử lý 10 triệu tokens/tháng với GPT-4.1:
- HolySheep: $80/tháng
- API chính thức: $600/tháng
Tiết kiệm: $520/tháng = $6,240/năm

Vì Sao Chọn HolySheep - Lợi Thế Cạnh Tranh

1. Độ Trễ Thấp Nhất (<50ms)

Với cơ sở hạ tầng được tối ưu hóa tại Hong Kong và Singapore, HolySheep cung cấp độ trễ stream thấp nhất thị trường, đảm bảo trải nghiệm người dùng mượt mà.

2. Retry Mechanism Tích Hợp

Không cần implement retry logic phức tạp - HolySheep xử lý tự động với exponential backoff và circuit breaker.

3. Thanh Toán Linh Hoạt

Hỗ trợ WeChat Pay, Alipay, và credit card quốc tế - phù hợp với cả developer Trung Quốc và quốc tế.

4. Tín Dụng Miễn Phí

Đăng ký tại đây để nhận tín dụng miễn phí ngay khi bắt đầu.

Triển Khai Kỹ Thuật - Retry Mechanism Và断点续传

Kiến Trúc Xử Lý Stream Interruption

┌─────────────────────────────────────────────────────────────┐
│                    STREAM PROCESSING FLOW                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  User Request ──► Stream Initiated ──► Receive Chunks       │
│                              │              │               │
│                              ▼              ▼               │
│                        ┌──────────┐   ┌──────────┐         │
│                        │ Buffer   │   │ Process   │         │
│                        │ Storage  │   │ Chunk     │         │
│                        └──────────┘   └──────────┘         │
│                              │              │               │
│                     ┌────────┴──────────────┴────────┐      │
│                     │     INTERRUPTION CHECK        │      │
│                     └───────────────────────────────┘      │
│                                   │                         │
│              ┌────────────────────┼────────────────────┐    │
│              ▼                    ▼                    ▼    │
│       ┌────────────┐      ┌────────────┐       ┌──────────┐ │
│       │ Continue   │      │ Retry with │       │ Resume   │ │
│       │ Processing │      │ Backoff    │       │ Checkpoint│ │
│       └────────────┘      └────────────┘       └──────────┘ │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Python Implementation - Retry Mechanism Hoàn Chỉnh

import requests
import json
import time
from typing import Iterator, Optional, Callable
from dataclasses import dataclass, field
from datetime import datetime, timedelta
import threading
import queue

@dataclass
class StreamConfig:
    """Cấu hình cho stream processing"""
    base_url: str = "https://api.holysheep.ai/v1"
    api_key: str = "YOUR_HOLYSHEEP_API_KEY"
    model: str = "gpt-4.1"
    max_retries: int = 5
    initial_backoff: float = 0.5  # seconds
    max_backoff: float = 32.0     # seconds
    timeout: int = 60              # seconds
    checkpoint_enabled: bool = True
    buffer_size: int = 100        # chunks

@dataclass
class Checkpoint:
    """Lưu trữ checkpoint để resume"""
    message_id: str
    conversation_id: Optional[str]
    prompt_hash: str
    last_chunk_index: int = 0
    accumulated_content: str = ""
    timestamp: datetime = field(default_factory=datetime.now)
    metadata: dict = field(default_factory=dict)

class GPTStreamHandler:
    """
    Xử lý stream output với retry mechanism và断点续传
    Author: HolySheep AI Technical Team
    """
    
    def __init__(self, config: StreamConfig):
        self.config = config
        self.checkpoint_storage: dict[str, Checkpoint] = {}
        self.chunk_buffer: queue.Queue = queue.Queue(maxsize=config.buffer_size)
        self._lock = threading.Lock()
    
    def stream_with_retry(
        self,
        messages: list[dict],
        on_chunk: Callable[[str], None],
        on_error: Optional[Callable[[Exception], None]] = None,
        checkpoint_id: Optional[str] = None
    ) -> Iterator[str]:
        """
        Stream response với automatic retry và checkpoint resume
        
        Args:
            messages: Danh sách messages theo format OpenAI
            on_chunk: Callback cho mỗi chunk nhận được
            on_error: Callback khi có lỗi
            checkpoint_id: ID để track checkpoint
        
        Yields:
            str: Các chunk text từ stream
        """
        retry_count = 0
        backoff = self.config.initial_backoff
        start_from_checkpoint = None
        
        # Kiểm tra checkpoint cũ
        if checkpoint_id and self.config.checkpoint_enabled:
            start_from_checkpoint = self._load_checkpoint(checkpoint_id, messages)
            if start_from_checkpoint:
                print(f"Resuming from checkpoint: index {start_from_checkpoint.last_chunk_index}")
        
        headers = {
            "Authorization": f"Bearer {self.config.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": self.config.model,
            "messages": messages,
            "stream": True,
            "temperature": 0.7,
            "max_tokens": 4096
        }
        
        while retry_count <= self.config.max_retries:
            try:
                response = requests.post(
                    f"{self.config.base_url}/chat/completions",
                    headers=headers,
                    json=payload,
                    stream=True,
                    timeout=self.config.timeout
                )
                
                if response.status_code != 200:
                    raise Exception(f"HTTP {response.status_code}: {response.text}")
                
                chunk_index = start_from_checkpoint.last_chunk_index if start_from_checkpoint else 0
                accumulated = start_from_checkpoint.accumulated_content if start_from_checkpoint else ""
                
                for line in response.iter_lines():
                    if not line:
                        continue
                    
                    line_text = line.decode('utf-8')
                    if not line_text.startswith('data: '):
                        continue
                    
                    data = line_text[6:]  # Remove 'data: ' prefix
                    
                    if data == '[DONE]':
                        # Lưu checkpoint cuối cùng
                        if checkpoint_id:
                            self._save_checkpoint(checkpoint_id, messages, chunk_index, accumulated)
                        break
                    
                    try:
                        chunk_data = json.loads(data)
                        delta = chunk_data.get('choices', [{}])[0].get('delta', {})
                        content = delta.get('content', '')
                        
                        if content:
                            chunk_index += 1
                            accumulated += content
                            on_chunk(content)
                            yield content
                            
                            # Save checkpoint periodically (every 10 chunks)
                            if checkpoint_id and chunk_index % 10 == 0:
                                self._save_checkpoint(checkpoint_id, messages, chunk_index, accumulated)
                    
                    except json.JSONDecodeError:
                        continue
                
                # Thành công - xóa checkpoint cũ
                if checkpoint_id:
                    self._delete_checkpoint(checkpoint_id)
                return
                
            except requests.exceptions.Timeout as e:
                retry_count += 1
                if on_error:
                    on_error(e)
                if retry_count <= self.config.max_retries:
                    print(f"Timeout - Retry {retry_count}/{self.config.max_retries} sau {backoff}s")
                    time.sleep(backoff)
                    backoff = min(backoff * 2, self.config.max_backoff)
                else:
                    raise Exception(f"Max retries exceeded after timeout") from e
                    
            except requests.exceptions.RequestException as e:
                retry_count += 1
                if on_error:
                    on_error(e)
                if retry_count <= self.config.max_retries:
                    print(f"Request error - Retry {retry_count}/{self.config.max_retries} sau {backoff}s: {e}")
                    time.sleep(backoff)
                    backoff = min(backoff * 2, self.config.max_backoff)
                else:
                    raise Exception(f"Max retries exceeded after request error") from e
    
    def _load_checkpoint(self, checkpoint_id: str, messages: list[dict]) -> Optional[Checkpoint]:
        """Load checkpoint từ storage"""
        with self._lock:
            if checkpoint_id in self.checkpoint_storage:
                cp = self.checkpoint_storage[checkpoint_id]
                # Verify message hash matches
                if self._verify_messages(cp.prompt_hash, messages):
                    return cp
        return None
    
    def _save_checkpoint(
        self,
        checkpoint_id: str,
        messages: list[dict],
        chunk_index: int,
        content: str
    ):
        """Save checkpoint to storage"""
        checkpoint = Checkpoint(
            message_id=checkpoint_id,
            conversation_id=None,
            prompt_hash=self._hash_messages(messages),
            last_chunk_index=chunk_index,
            accumulated_content=content,
            timestamp=datetime.now()
        )
        with self._lock:
            self.checkpoint_storage[checkpoint_id] = checkpoint
    
    def _delete_checkpoint(self, checkpoint_id: str):
        """Xóa checkpoint sau khi hoàn thành"""
        with self._lock:
            self.checkpoint_storage.pop(checkpoint_id, None)
    
    def _hash_messages(self, messages: list[dict]) -> str:
        """Tạo hash để verify messages"""
        import hashlib
        content = json.dumps(messages, sort_keys=True)
        return hashlib.sha256(content.encode()).hexdigest()[:16]
    
    def _verify_messages(self, stored_hash: str, messages: list[dict]) -> bool:
        """Verify messages match stored hash"""
        return self._hash_messages(messages) == stored_hash



============== USAGE EXAMPLE ==============


def demo_stream_handler():
    """Ví dụ sử dụng GPTStreamHandler với retry và checkpoint"""
    
    config = StreamConfig(
        base_url="https://api.holysheep.ai/v1",
        api_key="YOUR_HOLYSHEEP_API_KEY",
        model="gpt-4.1",
        max_retries=5,
        checkpoint_enabled=True
    )
    
    handler = GPTStreamHandler(config)
    
    messages = [
        {"role": "system", "content": "Bạn là trợ lý AI hữu ích."},
        {"role": "user", "content": "Giải thích về retry mechanism trong streaming API"}
    ]
    
    collected_response = []
    checkpoint_id = "user_session_123"
    
    def on_chunk(chunk):
        collected_response.append(chunk)
        print(f"Chunk nhận được: {chunk}", end="", flush=True)
    
    def on_error(error):
        print(f"\nLỗi xảy ra: {type(error).__name__}")
    
    try:
        for chunk in handler.stream_with_retry(
            messages=messages,
            on_chunk=on_chunk,
            on_error=on_error,
            checkpoint_id=checkpoint_id
        ):
            pass  # Chunks đã được xử lý trong on_chunk
        
        print(f"\n\nTổng response: {''.join(collected_response)}")
        
    except Exception as e:
        print(f"\nStream thất bại sau nhiều lần thử: {e}")
        print(f"Checkpoint đã được lưu. Bạn có thể resume sau.")


if __name__ == "__main__":
    demo_stream_handler()

JavaScript/Node.js Implementation

/**
 * GPT-5 Stream Handler với Retry Mechanism và断点续传
 * Compatible với HolySheep API
 */

const EventSource = require('eventsource');
const crypto = require('crypto');

// ============== CONFIGURATION ==============

const STREAM_CONFIG = {
    baseUrl: 'https://api.holysheep.ai/v1',
    apiKey: 'YOUR_HOLYSHEEP_API_KEY',
    model: 'gpt-4.1',
    maxRetries: 5,
    initialBackoff: 500,      // ms
    maxBackoff: 32000,       // ms
    timeout: 60000,          // ms
    checkpointEnabled: true,
    checkpointInterval: 10   // Save every N chunks
};

// ============== CHECKPOINT STORAGE ==============

class CheckpointStorage {
    constructor() {
        this.checkpoints = new Map();
    }
    
    save(checkpointId, data) {
        this.checkpoints.set(checkpointId, {
            ...data,
            timestamp: new Date().toISOString()
        });
    }
    
    load(checkpointId) {
        return this.checkpoints.get(checkpointId) || null;
    }
    
    delete(checkpointId) {
        this.checkpoints.delete(checkpointId);
    }
    
    clear() {
        this.checkpoints.clear();
    }
}

// ============== STREAM HANDLER ==============

class GPTStreamHandler {
    constructor(config = STREAM_CONFIG) {
        this.config = config;
        this.checkpointStorage = new CheckpointStorage();
        this.abortController = null;
    }
    
    /**
     * Stream với automatic retry và checkpoint resume
     */
    async *streamWithRetry(messages, options = {}) {
        const {
            onChunk = () => {},
            onError = () => {},
            onComplete = () => {},
            checkpointId = null
        } = options;
        
        let retryCount = 0;
        let backoff = this.config.initialBackoff;
        let startFromCheckpoint = null;
        let chunkIndex = 0;
        let accumulatedContent = '';
        
        // Load checkpoint nếu có
        if (checkpointId && this.config.checkpointEnabled) {
            startFromCheckpoint = this.checkpointStorage.load(checkpointId);
            if (startFromCheckpoint && this.verifyMessages(startFromCheckpoint.promptHash, messages)) {
                console.log(Resuming from checkpoint: index ${startFromCheckpoint.lastChunkIndex});
                chunkIndex = startFromCheckpoint.lastChunkIndex;
                accumulatedContent = startFromCheckpoint.accumulatedContent;
            }
        }
        
        while (retryCount <= this.config.maxRetries) {
            this.abortController = new AbortController();
            
            try {
                const response = await fetch(${this.config.baseUrl}/chat/completions, {
                    method: 'POST',
                    headers: {
                        'Authorization': Bearer ${this.config.apiKey},
                        'Content-Type': 'application/json'
                    },
                    body: JSON.stringify({
                        model: this.config.model,
                        messages: messages,
                        stream: true,
                        temperature: 0.7,
                        max_tokens: 4096
                    }),
                    signal: this.abortController.signal
                });
                
                if (!response.ok) {
                    const errorText = await response.text();
                    throw new Error(HTTP ${response.status}: ${errorText});
                }
                
                const reader = response.body.getReader();
                const decoder = new TextDecoder();
                let buffer = '';
                
                while (true) {
                    const { done, value } = await reader.read();
                    
                    if (done) break;
                    
                    buffer += decoder.decode(value, { stream: true });
                    const lines = buffer.split('\n');
                    buffer = lines.pop() || '';
                    
                    for (const line of lines) {
                        if (!line.startsWith('data: ')) continue;
                        
                        const data = line.slice(6);
                        
                        if (data === '[DONE]') {
                            // Save final checkpoint
                            if (checkpointId) {
                                this.saveCheckpoint(checkpointId, messages, chunkIndex, accumulatedContent);
                            }
                            onComplete(accumulatedContent);
                            return;
                        }
                        
                        try {
                            const parsed = JSON.parse(data);
                            const content = parsed.choices?.[0]?.delta?.content || '';
                            
                            if (content) {
                                chunkIndex++;
                                accumulatedContent += content;
                                
                                onChunk(content, chunkIndex);
                                yield content;
                                
                                // Save checkpoint periodically
                                if (checkpointId && chunkIndex % this.config.checkpointInterval === 0) {
                                    this.saveCheckpoint(checkpointId, messages, chunkIndex, accumulatedContent);
                                }
                            }
                        } catch (e) {
                            // Skip invalid JSON
                        }
                    }
                }
                
                // Success - delete checkpoint
                if (checkpointId) {
                    this.checkpointStorage.delete(checkpointId);
                }
                return;
                
            } catch (error) {
                retryCount++;
                
                if (error.name === 'AbortError') {
                    // User cancelled
                    throw error;
                }
                
                onError(error, retryCount);
                
                if (retryCount <= this.config.maxRetries) {
                    console.log(Retry ${retryCount}/${this.config.maxRetries} sau ${backoff}ms);
                    await this.sleep(backoff);
                    backoff = Math.min(backoff * 2, this.config.maxBackoff);
                } else {
                    throw new Error(Max retries exceeded: ${error.message});
                }
            }
        }
    }
    
    /**
     * Save checkpoint
     */
    saveCheckpoint(checkpointId, messages, chunkIndex, content) {
        if (!this.config.checkpointEnabled) return;
        
        this.checkpointStorage.save(checkpointId, {
            messageId: checkpointId,
            promptHash: this.hashMessages(messages),
            lastChunkIndex: chunkIndex,
            accumulatedContent: content
        });
        
        console.log(Checkpoint saved: ${checkpointId} at index ${chunkIndex});
    }
    
    /**
     * Verify messages match stored hash
     */
    verifyMessages(storedHash, messages) {
        return this.hashMessages(messages) === storedHash;
    }
    
    /**
     * Hash messages for verification
     */
    hashMessages(messages) {
        const content = JSON.stringify(messages, Object.keys(messages).sort());
        return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
    }
    
    /**
     * Sleep helper
     */
    sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
    
    /**
     * Abort current stream
     */
    abort() {
        if (this.abortController) {
            this.abortController.abort();
        }
    }
}

// ============== USAGE EXAMPLE ==============

async function demoStreamHandler() {
    const handler = new GPTStreamHandler();
    
    const messages = [
        { role: 'system', content: 'Bạn là trợ lý AI hữu ích.' },
        { role: 'user', content: 'Giải thích về断点续传 trong streaming API' }
    ];
    
    const checkpointId = 'session_user_456';
    const collectedResponse = [];
    
    try {
        console.log('Bắt đầu stream...\n');
        
        for await (const chunk of handler.streamWithRetry(messages, {
            checkpointId: checkpointId,
            
            onChunk: (content, index) => {
                collectedResponse.push(content);
                process.stdout.write([${index}] ${content});
            },
            
            onError: (error, retryCount) => {
                console.error(\nLỗi (Retry ${retryCount}):, error.message);
            },
            
            onComplete: (fullResponse) => {
                console.log('\n\n=== Stream hoàn thành ===');
                console.log('Tổng độ dài:', fullResponse.length, 'characters');
            }
        })) {
            // Chunk đã được xử lý trong onChunk callback
        }
        
    } catch (error) {
        console.error('\nStream thất bại:', error.message);
        console.log('Checkpoint đã được lưu. Có thể resume sau.');
    }
}

// Chạy demo
demoStreamHandler().catch(console.error);

// Export for module usage
module.exports = { GPTStreamHandler, STREAM_CONFIG, CheckpointStorage };

Lỗi Thường Gặp Và Cách Khắc Phục

1. Lỗi "Connection reset by peer" Khi Stream

# Triệu chứng: Stream bị ngắt đột ngột với lỗi connection reset

Nguyên nhân: Server timeout hoặc network instability



Giải pháp: Implement connection pooling với retry


import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_session_with_retry():
    """Tạo session với automatic retry cho connection errors"""
    session = requests.Session()
    
    retry_strategy = Retry(
        total=5,
        backoff_factor=0.5,
        status_forcelist=[429, 500, 502, 503, 504],
        allowed_methods=["POST", "GET"],
        raise_on_status=False
    )
    
    adapter = HTTPAdapter(
        max_retries=retry_strategy,
        pool_connections=10,
        pool_maxsize=20
    )
    
    session.mount("https://", adapter)
    session.mount("http://", adapter)
    
    return session


Sử dụng:

session = create_session_with_retry()
response = session.post(
    f"{BASE_URL}/chat/completions",
    headers=headers,
    json=payload,
    stream=True,
    timeout=(5, 60)  # (connect_timeout, read_timeout)
)

2. Lỗi "JSONDecodeError" Khi Parse Stream Chunks

# Triệu chứng: Lỗi parsing khi nhận data từ stream

Nguyên nhân: Incomplete JSON hoặc malformed response



Giải pháp: Implement robust JSON parsing với error handling


import json
import re

def parse_sse_line(line: str) -> dict | None:
    """
    Parse Server-Sent Events line một cách an toàn
    Xử lý các trường hợp edge case
    """
    line = line.strip()
    
    # Skip empty lines
    if not line:
        return None
    
    # Chỉ xử lý data field
    if not line.startswith('data: '):
        return None
    
    data_content = line[6:]  # Remove 'data: ' prefix
    
    # Xử lý [DONE] marker
    if data_content == '[DONE]':
        return {'type': 'done'}
    
    # Thử parse JSON
    try:
        return json.loads(data_content)
    except json.JSONDecodeError as e:
        # Thử xử lý incomplete JSON
        # Ví dụ: {"choices": [{"delta": {"content": "hel
        if data_content.endswith('"') or data_content.endswith(','):
            # Có thể là incomplete string
            print(f"Warning: Incomplete JSON detected: {data_content[:50]}...")
            
            # Thử fix bằng cách complete JSON structure
            if '{' in data_content and '}' not in data_content:
                # Thử append closing brace
                try:
                    fixed = data_content + '}}'
                    return json.loads(fixed)
                except:
                    pass
        
        print(f"Error parsing JSON: {e}")
        return None

def process_stream_response(response):
    """Process stream response với robust error handling"""
    buffer = ""
    
    for chunk in response.iter_content(chunk_size=1, decode_unicode=True):
        buffer += chunk
        
        # Xử lý khi có complete line
        if '\n' in buffer:
            lines = buffer.split('\n')
            buffer = lines.pop()  # Giữ lại phần chưa complete
            
            for line in lines:
                parsed = parse_sse_line(line)
                if parsed and parsed.get('type') != 'done':
                    yield parsed

3. Lỗi "Maximum retries exceeded" Với Exponential Backoff

# Triệu chứng: Retry nhiều lần nhưng vẫn thất bại

Nguyên nhân: Server overloaded hoặc rate limiting



Giải pháp: Implement circuit breaker pattern


import time
import threading
from enum import Enum
from dataclasses import dataclass
from typing import Callable, TypeVar

T = TypeVar('T')

class CircuitState(Enum):
    CLOSED = "closed"      # Normal operation
    OPEN = "open"          # Failing, reject requests
    HALF_OPEN = "half_open"  # Testing if service recovered

@dataclass
class CircuitBreakerConfig:
    failure_threshold: int = 5
    success_threshold: int = 2
    timeout: int = 60  # seconds
    half_open_max_calls: int = 3

class CircuitBreaker:
    """
    Circuit Breaker implementation để tránh cascade failures
    """
    
    def __init__(self, config: CircuitBreakerConfig):
        self.config = config
        self.state = CircuitState.CLOSED
        self.failure_count = 0
        self.success_count = 0
        self.last_failure_time: float | None = None
        self._lock = threading.Lock()
        self.half_open_calls = 0
    
    def call(self, func: Callable[..., T], *args, **kwargs) -> T:
        """Execute function với circuit breaker protection"""
        
        with self._lock:
            if self.state == CircuitState.OPEN:
                if self._should_attempt_reset():
                    self.state = CircuitState.HALF_OPEN
                    self.half_open_calls = 0
                else:
                    raise CircuitBreakerOpenError("Circuit breaker is OPEN")
            
            if self.state == CircuitState.HALF_OPEN:
                if self.half_open_calls >= self.config.half_open_max_calls:
                    raise CircuitBreakerOpenError("Circuit breaker is HALF_OPEN, max calls reached")
                self.half_open_calls += 1
        
        try:
            result = func(*args, **kwargs)
            self._on_success()
            return result
        except Exception as e:
            self._on_failure()
            raise e
    
    def _should_attempt_reset(self) -> bool:
        """Check if enough time has passed to attempt reset"""
        if self.last_failure_time is None:

Tài nguyên liên quan
Bài viết liên quan