Timeout Configuration cho AI Services: Hướng Dẫn Toàn Diện Từ Thực Chiến

Mở đầu: Câu chuyện về đêm "thảm họa" của tôi

Tại sao Timeout lại quan trọng đến vậy?

• Độ trễ (Latency): HolySheheep AI đạt <50ms với edge caching, nhưng request đầu tiên vẫn cần thời gian xử lý
• Chi phí: Mỗi request timeout không đúng cách = tiền bay mất không hoàn tiền
• UX: User chờ 30s = tỷ lệ bounce tăng 90%

Code Examples: Timeout Configuration Thực Chiến

1. Python với requests library

import requests
import time

Configuration tối ưu cho HolySheep AI
Tôi đã thử nghiệm: connect=5s, read=30s là sweet spot cho hầu hết use cases

config = {
    "base_url": "https://api.holysheep.ai/v1",
    "api_key": "YOUR_HOLYSHEEP_API_KEY",
    "timeout": {
        "connect": 5.0,      # 5 giây - tránh DNS lookup chậm
        "read": 30.0,        # 30 giây - đủ cho context dài
        "write": 10.0        # 10 giây - request body nhỏ
    }
}

def call_ai_service(prompt, model="gpt-4.1"):
    """
    Implementation với automatic retry và exponential backoff
    """
    url = f"{config['base_url']}/chat/completions"
    headers = {
        "Authorization": f"Bearer {config['api_key']}",
        "Content-Type": "application/json"
    }
    payload = {
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 1000
    }
    
    max_retries = 3
    for attempt in range(max_retries):
        try:
            response = requests.post(
                url,
                json=payload,
                headers=headers,
                timeout=(config['timeout']['connect'], 
                         config['timeout']['read'])
            )
            response.raise_for_status()
            return response.json()
            
        except requests.exceptions.Timeout:
            wait_time = 2 ** attempt  # Exponential backoff: 1s, 2s, 4s
            print(f"Timeout lần {attempt + 1}, thử lại sau {wait_time}s...")
            time.sleep(wait_time)
            
        except requests.exceptions.RequestException as e:
            print(f"Lỗi request: {e}")
            raise
    
    raise Exception("Đã thử 3 lần, không thành công")

Test với response time thực tế
start = time.time()
result = call_ai_service("Xin chào, bạn là ai?")
print(f"Response time: {(time.time() - start)*1000:.2f}ms")

2. Node.js với axios và circuit breaker

const axios = require('axios');

// Tôi khuyên dùng axios vì nó xử lý timeout granularity tốt hơn
// Đặc biệt hữu ích khi server respond headers nhưng body chậm

const holySheepClient = axios.create({
  baseURL: 'https://api.holysheep.ai/v1',
  timeout: 30000, // 30 giây - matching với HolySheep limits
  timeoutErrorMessage: 'AI Service timeout - vui lòng thử lại'
});

// Interceptors để log và retry tự động
holySheepClient.interceptors.response.use(
  response => {
    console.log(✅ Response: ${response.status} - ${response.headers['x-response-time']}ms);
    return response;
  },
  async error => {
    const config = error.config;
    
    // Retry logic với exponential backoff
    if (!config._retryCount) config._retryCount = 0;
    
    if (error.code === 'ECONNABORTED' && config._retryCount < 3) {
      config._retryCount++;
      const delay = Math.pow(2, config._retryCount) * 1000;
      
      console.log(⏳ Retry ${config._retryCount}/3 sau ${delay}ms...);
      await new Promise(resolve => setTimeout(resolve, delay));
      
      return holySheepClient(config);
    }
    
    // Parse error message thân thiện
    if (error.response) {
      console.error(❌ API Error: ${error.response.status} - ${JSON.stringify(error.response.data)});
    } else if (error.request) {
      console.error('❌ Không nhận được response - có thể network issue hoặc timeout');
    }
    
    return Promise.reject(error);
  }
);

// Wrapper function với retry logic
async function chatWithRetry(messages, model = 'gpt-4.1') {
  const maxTokens = 2000;
  const temperature = 0.7;
  
  try {
    const response = await holySheepClient.post('/chat/completions', {
      model,
      messages,
      max_tokens: maxTokens,
      temperature
    });
    
    return response.data.choices[0].message.content;
    
  } catch (error) {
    // Fallback: trả về cached response hoặc message thân thiện
    return "Xin lỗi, dịch vụ AI đang bận. Vui lòng thử lại sau.";
  }
}

// Performance monitoring
async function benchmarkModels() {
  const models = ['gpt-4.1', 'claude-sonnet-4.5', 'gemini-2.5-flash', 'deepseek-v3.2'];
  const testPrompt = "Giải thích khái niệm async/await trong 3 câu";
  
  for (const model of models) {
    const start = Date.now();
    await chatWithRetry([{role: 'user', content: testPrompt}], model);
    console.log(${model}: ${Date.now() - start}ms);
  }
}

3. Go với context và graceful shutdown

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

// TimeoutConfig - best practices từ production system của tôi
type TimeoutConfig struct {
    ConnectTimeout time.Duration // 5s cho DNS + TCP handshake
    ReadTimeout    time.Duration // 30s cho AI processing
    WriteTimeout   time.Duration // 10s cho request body
    MaxRetries     int           // 3 lần retry
    BaseDelay      time.Duration // 1s exponential backoff base
}

func NewTimeoutConfig() *TimeoutConfig {
    return &TimeoutConfig{
        ConnectTimeout: 5 * time.Second,
        ReadTimeout:    30 * time.Second,
        WriteTimeout:   10 * time.Second,
        MaxRetries:     3,
        BaseDelay:      1 * time.Second,
    }
}

type HolySheepClient struct {
    client  *http.Client
    baseURL string
    apiKey  string
    config  *TimeoutConfig
}

func NewHolySheepClient(apiKey string) *HolySheepClient {
    cfg := NewTimeoutConfig()
    
    // Transport với connection pooling
    transport := &http.Transport{
        MaxIdleConns:        100,
        IdleConnTimeout:     90 * time.Second,
        TLSHandshakeTimeout: 10 * time.Second,
    }
    
    return &HolySheepClient{
        client: &http.Client{
            Transport: transport,
            Timeout:   cfg.ReadTimeout, // Total timeout
        },
        baseURL: "https://api.holysheep.ai/v1",
        apiKey:  apiKey,
        config:  cfg,
    }
}

func (c *HolySheepClient) Chat(ctx context.Context, prompt string) (string, error) {
    url := fmt.Sprintf("%s/chat/completions", c.baseURL)
    
    // Tạo context với timeout cụ thể
    // Đây là pattern tôi dùng trong tất cả production code
    reqCtx, cancel := context.WithTimeout(ctx, c.config.ReadTimeout)
    defer cancel()
    
    reqBody := map[string]interface{}{
        "model":    "gpt-4.1",
        "messages": []map[string]string{{"role": "user", "content": prompt}},
    }
    
    req, err := http.NewRequestWithContext(reqCtx, "POST", url, nil)
    if err != nil {
        return "", fmt.Errorf("tạo request thất bại: %w", err)
    }
    
    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.apiKey))
    req.Header.Set("Content-Type", "application/json")
    
    // Execute với retry
    var lastErr error
    for attempt := 0; attempt < c.config.MaxRetries; attempt++ {
        if attempt > 0 {
            delay := c.config.BaseDelay * time.Duration(1<

┌─────────────────────────────────────────────────────────────────────────────┐
│ USE CASE                    │ CONNECT  │ READ    │ RECOMMENDATION            │
├─────────────────────────────────────────────────────────────────────────────┤
│ Chatbot đơn giản            │ 3s       │ 15s     │ Nhanh, user expect instant│
│ RAG/Embedding               │ 5s       │ 30s     │ Context dài cần thời gian │
│ Streaming responses         │ 5s       │ 60s     │ Token generation mất thời │
│ Batch processing            │ 10s      │ 120s    │ Xử lý nhiều documents     │
│ Code generation             │ 5s       │ 45s     │ Complex reasoning needed  │
│ Image generation            │ 10s      │ 90s     │ Stable Diffusion mất time │
└─────────────────────────────────────────────────────────────────────────────┘

# ❌ SAI - Không set connect timeout riêng
response = requests.post(url, json=payload, timeout=30)

✅ ĐÚNG - Tách biệt connect và read timeout
response = requests.post(
    url, 
    json=payload, 
    timeout=(5.0, 30.0)  # connect=5s, read=30s
)

Hoặc dùng session để reuse connection
session = requests.Session()
session.mount('https://api.holysheep.ai', requests.adapters.HTTPAdapter(
    pool_connections=10,
    pool_maxsize=20,
    max_retries=3
))
response = session.post(url, json=payload, timeout=(5.0, 30.0))

# ❌ SAI - max_tokens không giới hạn
payload = {
    "model": "gpt-4.1",
    "messages": [{"role": "user", "content": long_prompt}],
    # Không set max_tokens = timeout ngay lập tức
}

✅ ĐÚNG - Set reasonable max_tokens + monitoring
payload = {
    "model": "gpt-4.1",
    "messages": [{"role": "user", "content": long_prompt}],
    "max_tokens": 1000,  # Giới hạn output tokens
    "stream": False      # Non-streaming để đo lường dễ hơn
}

Monitoring function
def monitor_request_timing(response, expected_time_ms=500):
    actual_time = response.elapsed.total_seconds() * 1000
    if actual_time > expected_time_ms:
        print(f"⚠️ Request chậm hơn dự kiến: {actual_time:.2f}ms vs {expected_time_ms}ms")
    return actual_time

# ❌ SAI - Không giới hạn concurrency
async def process_all(items):
    tasks = [call_api(item) for item in items]  # 1000 tasks cùng lúc!
    return await asyncio.gather(*tasks)

✅ ĐÚNG - Semaphore giới hạn concurrency
import asyncio
from asyncio import Semaphore

async def process_all(items, max_concurrent=10):
    semaphore = Semaphore(max_concurrent)
    
    async def bounded_call(item):
        async with semaphore:
            return await call_api(item)
    
    tasks = [bounded_call(item) for item in items]
    # Chunking để tránh overwhelming
    results = []
    for i in range(0, len(tasks), 50):
        chunk = tasks[i:i+50]
        results.extend(await asyncio.gather(*chunk, return_exceptions=True))
    
    return results

Rate limiting với token bucket
class RateLimiter:
    def __init__(self, rate=100, per=60):  # 100 requests per 60s
        self.rate = rate
        self.interval = per / rate
        self.last_time = 0
    
    async def acquire(self):
        now = time.time()
        wait = self.interval - (now - self.last_time)
        if wait > 0:
            await asyncio.sleep(wait)
        self.last_time = time.time()