Bảo Mật AI API Cho Doanh Nghiệp: Triển Khai RBAC Và Audit Log Toàn Diện

Tháng 9 năm 2024, một đội ngũ thương mại điện tử tại Việt Nam triển khai hệ thống RAG (Retrieval-Augmented Generation) để hỗ trợ khách hàng 24/7. Sau 3 tháng vận hành, họ phát hiện một nhân viên marketing đã lạm dụng API key để scrape 2.3 triệu câu trả lời — tương đương $4,700 chi phí phát sinh chỉ trong một tuần. Không có audit log, không có cảnh báo, không có cách truy vết ai đã làm gì.

Bài viết này chia sẻ cách tôi xây dựng hệ thống bảo mật AI API từ con số 0 — bao gồm RBAC (Role-Based Access Control) và Audit Logging — để bạn không bao giờ rơi vào tình huống tương tự.

Tại Sao Bảo Mật AI API Không Thể Bỏ Qua?

Khác với API truyền thống, AI API có những rủi ro đặc thù:

• Chi phí khó kiểm soát: Mỗi request có thể tiêu tốn từ $0.001 đến $15 tùy model. Một vòng lặp lỗi có thể "đốt" hàng nghìn đô.
• Dữ liệu nhạy cảm: Prompt chứa thông tin khách hàng, tài liệu nội bộ, mã nguồn.
• Phân quyền theo ngữ cảnh: Developer cần quyền khác với data analyst, khác với admin.
• Compliance yêu cầu: SOC 2, GDPR, ISO 27001 đều yêu cầu audit trail đầy đủ.

Kiến Trúc RBAC Cho Hệ Thống AI API

Mô Hình Phân Quyền 4 Lớp

┌─────────────────────────────────────────────────────────────┐
│                    PERMISSION MATRIX                        │
├──────────────┬───────────┬──────────┬───────────┬────────────┤
│   Role       │  Chat     │  Embed   │  Fine-    │  Admin     │
│              │  Completion│ ding    │  Tuning   │  Panel     │
├──────────────┼───────────┼──────────┼───────────┼────────────┤
│ viewer       │    ✓      │    ✓     │    ✗      │    ✗       │
│ developer    │    ✓      │    ✓     │    ✗      │    ✗       │
│ data_scientist│   ✓     │    ✓     │    ✓      │    ✗       │
│ admin        │    ✓      │    ✓     │    ✓      │    ✓       │
└──────────────┴───────────┴──────────┴───────────┴────────────┘

QUY TẮC ĐẶT TÊN API KEY:
  holysheep_sk_live_xxxx    → Production (mãi mãi không share)
  holysheep_sk_test_xxxx    → Development/Testing
  holysheep_sk_readonly_xxx → Chỉ đọc, không gọi API

Schema Database Cho RBAC

-- PostgreSQL Schema cho hệ thống RBAC AI API
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) UNIQUE NOT NULL,
    hashed_password VARCHAR(255) NOT NULL,
    department VARCHAR(100),
    is_active BOOLEAN DEFAULT true,
    created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE roles (
    id SERIAL PRIMARY KEY,
    name VARCHAR(50) UNIQUE NOT NULL,
    description TEXT,
    permissions JSONB NOT NULL DEFAULT '[]'
);

CREATE TABLE api_keys (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id) ON DELETE CASCADE,
    key_hash VARCHAR(64) UNIQUE NOT NULL,  -- SHA-256 hash của key thực
    key_prefix VARCHAR(20) NOT NULL,         -- 12 ký tự đầu để nhận diện
    name VARCHAR(100) NOT NULL,
    role_id INTEGER REFERENCES roles(id),
    rate_limit INT DEFAULT 60,              -- requests per minute
    monthly_limit DECIMAL(12,2) DEFAULT 1000.00, -- USD limit
    expires_at TIMESTAMP,
    last_used_at TIMESTAMP,
    created_at TIMESTAMP DEFAULT NOW()
);

-- Permissions JSONB structure
-- ["chat:create", "chat:read", "embedding:create", "finetune:read", "admin:users"]

Middleware Kiểm Tra Quyền Với HolySheep

// auth.middleware.ts - Middleware kiểm tra quyền cho Express/Fastify
import crypto from 'crypto';

interface PermissionContext {
  userId: string;
  role: string;
  permissions: string[];
  remainingBudget: number;
}

function hashApiKey(apiKey: string): string {
  return crypto.createHash('sha256').update(apiKey).digest('hex');
}

async function validateApiKey(apiKey: string): Promise<PermissionContext | null> {
  const keyHash = hashApiKey(apiKey);
  
  // Query database để lấy thông tin key
  const result = await db.query(`
    SELECT u.id, u.is_active, r.name as role, r.permissions,
           ak.monthly_limit, 
           COALESCE(SUM(a.cost), 0) as used_cost
    FROM api_keys ak
    JOIN users u ON ak.user_id = u.id
    JOIN roles r ON ak.role_id = r.id
    LEFT JOIN audit_logs a ON ak.id = a.api_key_id 
      AND a.created_at >= date_trunc('month', NOW())
    WHERE ak.key_hash = $1 AND ak.expires_at > NOW()
    GROUP BY u.id, u.is_active, r.name, r.permissions, ak.monthly_limit
  `, [keyHash]);

  if (result.rows.length === 0) return null;
  
  const key = result.rows[0];
  if (!key.is_active) return null;

  const usedCost = parseFloat(key.used_cost);
  const monthlyLimit = parseFloat(key.monthly_limit);
  
  if (usedCost >= monthlyLimit) {
    throw new Error('MONTHLY_LIMIT_EXCEEDED');
  }

  return {
    userId: key.id,
    role: key.role,
    permissions: key.permissions,
    remainingBudget: monthlyLimit - usedCost
  };
}

function checkPermission(permissions: string[], required: string): boolean {
  // Wildcard support: "chat:*" matches "chat:create", "chat:read"
  return permissions.some(p => {
    if (p === '*') return true;
    if (p === required) return true;
    const [category, action] = required.split(':');
    if (p === ${category}:*) return true;
    return false;
  });
}

// Middleware cho route
export function requirePermission(requiredPermission: string) {
  return async (req, res, next) => {
    try {
      const apiKey = req.headers['x-api-key'];
      if (!apiKey) {
        return res.status(401).json({ error: 'Missing API key' });
      }

      const context = await validateApiKey(apiKey);
      if (!context) {
        return res.status(401).json({ error: 'Invalid API key' });
      }

      if (!checkPermission(context.permissions, requiredPermission)) {
        return res.status(403).json({ 
          error: 'Insufficient permissions',
          required: requiredPermission 
        });
      }

      req.authContext = context;
      next();
    } catch (error) {
      if (error.message === 'MONTHLY_LIMIT_EXCEEDED') {
        return res.status(429).json({ 
          error: 'Monthly spending limit exceeded',
          upgrade: 'https://www.holysheep.ai/billing'
        });
      }
      next(error);
    }
  };
}

// Sử dụng với HolySheep API
export const proxyToHolySheep = async (req, res) => {
  const context = req.authContext;
  
  // Map permission to HolySheep endpoint
  const endpointMap = {
    'chat:create': '/chat/completions',
    'embedding:create': '/embeddings',
    'finetune:create': '/fine-tuning/jobs'
  };

  const holySheepResponse = await fetch(
    https://api.holysheep.ai/v1${endpointMap[req.permission]},
    {
      method: 'POST',
      headers: {
        'Authorization': Bearer ${process.env.HOLYSHEEP_API_KEY},
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        ...req.body,
        user_id: context.userId  // Track usage by user
      })
    }
  );

  // Log usage với chi phí thực tế
  await logAuditTrail(req, holySheepResponse);
  
  res.json(await holySheepResponse.json());
};

Audit Log: Ghi Nhật Ký Mọi Hoạt Động

Schema Audit Log Chi Tiết

-- Comprehensive audit log schema
CREATE TABLE audit_logs (
    id BIGSERIAL PRIMARY KEY,
    api_key_id UUID REFERENCES api_keys(id),
    user_id UUID REFERENCES users(id),
    
    -- Request details
    request_id VARCHAR(64) UNIQUE NOT NULL,  -- UUID cho trace
    request_method VARCHAR(10) NOT NULL,
    request_path VARCHAR(500) NOT NULL,
    request_headers JSONB,
    request_body JSONB,  -- Chỉ lưu non-sensitive fields
    
    -- Response details  
    response_status INT,
    response_body JSONB,
    
    -- Cost tracking (cực kỳ quan trọng!)
    model VARCHAR(100),
    input_tokens INT,
    output_tokens INT,
    cost_usd DECIMAL(12,6) NOT NULL,
    latency_ms INT,
    
    -- Security events
    event_type VARCHAR(50),  -- api_call, auth_failure, rate_limit, budget_alert
    ip_address INET,
    user_agent TEXT,
    geo_location JSONB,
    
    -- Compliance
    data_classification VARCHAR(50),  -- public, internal, confidential, restricted
    retention_until TIMESTAMP,
    
    created_at TIMESTAMP DEFAULT NOW()
);

-- Index cho performance và investigation
CREATE INDEX idx_audit_user_date ON audit_logs(user_id, created_at DESC);
CREATE INDEX idx_audit_api_key ON audit_logs(api_key_id, created_at DESC);
CREATE INDEX idx_audit_cost ON audit_logs(created_at DESC) WHERE cost_usd > 0;
CREATE INDEX idx_audit_security ON audit_logs(event_type, created_at DESC);

-- Partition theo tháng (cho retention policy)
CREATE TABLE audit_logs_2024_10 PARTITION OF audit_logs
    FOR VALUES FROM ('2024-10-01') TO ('2024-11-01');

Service Ghi Log Với Chi Phí Real-time

// audit-logger.service.ts
import { Pool } from 'pg';

interface AuditEntry {
  apiKeyId: string;
  userId: string;
  requestId: string;
  request: {
    method: string;
    path: string;
    headers: Record<string, string>;
    body: Record<string, any>;
  };
  response: {
    status: number;
    body: any;
  };
  model?: string;
  usage?: {
    inputTokens: number;
    outputTokens: number;
  };
  latencyMs: number;
  eventType: 'api_call' | 'auth_failure' | 'rate_limit' | 'budget_alert';
  ipAddress: string;
  dataClassification: string;
}

// HolySheep pricing reference (2026)
const MODEL_PRICING = {
  'gpt-4.1': { input: 8, output: 24 },           // $8/MTok input, $24/MTok output
  'claude-sonnet-4.5': { input: 15, output: 75 },
  'gemini-2.5-flash': { input: 2.50, output: 10 },
  'deepseek-v3.2': { input: 0.42, output: 1.68 }  // ★ Best value!
};

class AuditLogger {
  private pool: Pool;
  private buffer: AuditEntry[] = [];
  private flushInterval: NodeJS.Timeout;

  constructor(pool: Pool) {
    this.pool = pool;
    
    // Flush mỗi 5 giây hoặc khi buffer đầy
    this.flushInterval = setInterval(() => this.flush(), 5000);
  }

  calculateCost(model: string, inputTokens: number, outputTokens: number): number {
    const pricing = MODEL_PRICING[model] || MODEL_PRICING['deepseek-v3.2'];
    return (inputTokens / 1_000_000) * pricing.input + 
           (outputTokens / 1_000_000) * pricing.output;
  }

  async log(entry: AuditEntry) {
    // Tính cost ngay lập tức
    let costUSD = 0;
    if (entry.usage && entry.model) {
      costUSD = this.calculateCost(
        entry.model,
        entry.usage.inputTokens,
        entry.usage.outputTokens
      );
    }

    const geoLocation = await this.getGeoLocation(entry.ipAddress);

    this.buffer.push({
      ...entry,
      response: {
        ...entry.response,
        body: this.sanitizeResponse(entry.response.body)
      }
    });

    // Auto-flush if buffer > 100
    if (this.buffer.length >= 100) {
      await this.flush();
    }

    // Check budget alert
    if (entry.eventType === 'api_call' && costUSD > 0) {
      await this.checkBudgetThreshold(entry.apiKeyId, costUSD);
    }
  }

  private sanitizeResponse(body: any): any {
    if (!body) return body;
    // Remove sensitive fields
    const sanitized = { ...body };
    delete sanitized.api_key;
    delete sanitized.token;
    return sanitized;
  }

  private async getGeoLocation(ip: string): Promise<any> {
    // Sử dụng free GeoIP service
    try {
      const response = await fetch(http://ip-api.com/json/${ip});
      const data = await response.json();
      return { country: data.country, city: data.city, lat: data.lat, lon: data.lon };
    } catch {
      return null;
    }
  }

  private async checkBudgetThreshold(apiKeyId: string, costUSD: number) {
    const key = await this.pool.query(
      `SELECT monthly_limit, (SELECT COALESCE(SUM(cost_usd), 0) 
       FROM audit_logs WHERE api_key_id = $1 
       AND created_at >= date_trunc('month', NOW())) as used
       FROM api_keys WHERE id = $1`,
      [apiKeyId]
    );

    if (key.rows.length > 0) {
      const { monthly_limit, used } = key.rows[0];
      const usagePercent = (parseFloat(used) / monthly_limit) * 100;

      // Alert at 50%, 75%, 90%, 100%
      const thresholds = [50, 75, 90, 100];
      for (const threshold of thresholds) {
        if (usagePercent >= threshold && usagePercent < threshold + 1) {
          await this.sendBudgetAlert(apiKeyId, threshold, used, monthly_limit);
        }
      }
    }
  }

  private async sendBudgetAlert(
    apiKeyId: string, 
    threshold: number, 
    used: number, 
    limit: number
  ) {
    // Gửi email/Slack notification
    console.log(🚨 BUDGET ALERT [${threshold}%]: $${used}/$${limit} used for key ${apiKeyId});
    
    await this.pool.query(
      `INSERT INTO audit_logs (api_key_id, event_type, request_path, cost_usd)
       VALUES ($1, 'budget_alert', $2, 0)`,
      [apiKeyId, Budget reached ${threshold}%: $${used}/$${limit}]
    );
  }

  async flush() {
    if (this.buffer.length === 0) return;

    const entries = [...this.buffer];
    this.buffer = [];

    const values = entries.map((e, i) => {
      const offset = i * 14;
      return `($${offset+1}, $${offset+2}, $${offset+3}, $${offset+4}, 
               $${offset+5}, $${offset+6}, $${offset+7}, $${offset+8},
               $${offset+9}, $${offset+10}, $${offset+11}, $${offset+12},
               $${offset+13}, $${offset+14})`;
    }).join(', ');

    try {
      await this.pool.query(`
        INSERT INTO audit_logs (
          api_key_id, user_id, request_id, request_method, request_path,
          request_headers, request_body, response_status, response_body,
          model, input_tokens, output_tokens, cost_usd, latency_ms,
          event_type, ip_address, data_classification, created_at
        ) VALUES ${values}
      `, entries.flatMap(e => [
        e.apiKeyId, e.userId, e.requestId, e.request.method, e.request.path,
        JSON.stringify(e.request.headers), JSON.stringify(e.request.body),
        e.response.status, JSON.stringify(e.response.body),
        e.model || null, e.usage?.inputTokens || null, e.usage?.outputTokens || null,
        this.calculateCost(e.model || '', e.usage?.inputTokens || 0, e.usage?.outputTokens || 0),
        e.latencyMs, e.eventType, e.ipAddress, e.dataClassification, new Date()
      ]));
    } catch (error) {
      console.error('Failed to flush audit logs:', error);
      // Re-add to buffer on failure
      this.buffer.unshift(...entries);
    }
  }
}

export const auditLogger = new AuditLogger(new Pool({ connectionString: process.env.DATABASE_URL }));

Dashboard Giám Sát Chi Phí Theo Thời Gian Thực

<!-- real-time-cost-dashboard.html -->
<!DOCTYPE html>
<html lang="vi">
<head>
    <meta charset="UTF-8">
    <title>HolySheep AI - Giám sát chi phí real-time</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <style>
        body { font-family: -apple-system, sans-serif; background: #0f172a; color: #fff; padding: 20px; }
        .metric-card { 
            background: #1e293b; border-radius: 12px; padding: 20px; margin: 10px;
            display: inline-block; min-width: 200px;
        }
        .metric-value { font-size: 2em; font-weight: bold; color: #10b981; }
        .metric-label { color: #94a3b8; margin-top: 5px; }
        .warning { color: #f59e0b; }
        .danger { color: #ef4444; }
        table { width: 100%; border-collapse: collapse; margin-top: 20px; }
        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #334155; }
        th { background: #1e293b; }
    </style>
</head>
<body>
    <h1>📊 Dashboard Giám Sát Chi Phí AI API</h1>
    
    <div id="metrics">
        <div class="metric-card">
            <div class="metric-value" id="today-cost">$0.00</div>
            <div class="metric-label">Chi phí hôm nay</div>
        </div>
        <div class="metric-card">
            <div class="metric-value" id="month-cost">$0.00</div>
            <div class="metric-label">Chi phí tháng này</div>
        </div>
        <div class="metric-card">
            <div class="metric-value" id="requests-count">0</div>
            <div class="metric-label">Tổng requests</div>
        </div>
        <div class="metric-card">
            <div class="metric-value" id="avg-latency">0ms</div>
            <div class="metric-label">Latency trung bình</div>
        </div>
    </div>

    <canvas id="costChart" width="400" height="100"></canvas>
    
    <h2>Top 10 API Keys theo chi phí</h2>
    <table id="top-keys">
        <thead>
            <tr>
                <th>API Key</th>
                <th>User</th>
                <th>Chi phí</th>
                <th>Requests</th>
                <th>Budget %</th>
            </tr>
        </thead>
        <tbody id="keys-body"></tbody>
    </table>

    <script>
        // HolySheep API endpoint
        const HOLYSHEEP_API = 'https://api.holysheep.ai/v1';
        
        async function fetchMetrics() {
            const response = await fetch('/api/admin/metrics', {
                headers: { 'Authorization': 'Bearer YOUR_ADMIN_KEY' }
            });
            const data = await response.json();
            
            // Update metrics
            document.getElementById('today-cost').textContent = $${data.todayCost.toFixed(2)};
            document.getElementById('month-cost').textContent = $${data.monthCost.toFixed(2)};
            document.getElementById('requests-count').textContent = data.totalRequests.toLocaleString();
            document.getElementById('avg-latency').textContent = ${data.avgLatency}ms;
            
            // Color coding
            const costEl = document.getElementById('today-cost');
            if (data.todayCost > 100) costEl.className = 'metric-value danger';
            else if (data.todayCost > 50) costEl.className = 'metric-value warning';
            
            // Update table
            const tbody = document.getElementById('keys-body');
            tbody.innerHTML = data.topKeys.map(k => `
                <tr>
                    <td>${k.keyPrefix}...</td>
                    <td>${k.userEmail}</td>
                    <td>$${k.cost.toFixed(4)}</td>
                    <td>${k.requests}</td>
                    <td>
                        <div style="background: #334155; border-radius: 4px;">
                            <div style="width: ${k.budgetPercent}%; background: ${
                                k.budgetPercent > 90 ? '#ef4444' : 
                                k.budgetPercent > 70 ? '#f59e0b' : '#10b981'
                            }; height: 20px; border-radius: 4px;"></div>
                        </div>
                    </td>
                </tr>
            `).join('');
            
            // Update chart
            updateChart(data.hourlyCosts);
        }

        // Auto-refresh every 30 seconds
        setInterval(fetchMetrics, 30000);
        fetchMetrics();
    </script>
</body>
</html>

So Sánh Chi Phí: HolySheep vs. OpenAI/Anthropic

Model	HolySheep Input	OpenAI Input	Tiết kiệm	Độ trễ P50
GPT-4.1 / Claude Sonnet 4.5	$8/MTok	$15-30/MTok	73-85%	<800ms
Gemini 2.5 Flash	$2.50/MTok	$3.50/MTok	29%	<400ms
DeepSeek V3.2	$0.42/MTok	Không có tương đương	So sánh không áp dụng	<300ms
Embedding (text-embedding-3)	$0.10/MTok	$0.13/MTok	23%	<50ms

Phù hợp / Không phù hợp với ai

✅ Nên triển khai RBAC + Audit Log nếu bạn:

• Đang vận hành hệ thống AI API cho nhiều team hoặc khách hàng
• Cần comply với SOC 2, ISO 27001, GDPR hoặc các tiêu chuẩn bảo mật
• Muốn kiểm soát chi phí AI một cách chi tiết theo từng user/department
• Lo ngại về việc API key bị lạm dụng hoặc chia sẻ trái phép
• Cần trace và debug các vấn đề về AI response

❌ Có thể bỏ qua nếu:

• Chỉ là developer solo test nghiên cứu
• Budget rất nhỏ và chấp nhận rủi ro
• Hệ thống chỉ internal use với trust level cao

Giá và ROI

Quy mô	Chi phí hàng tháng	Tính năng	ROI (so với không có bảo mật)
Startup (5-10 users)	Miễn phí - $50	3 API keys, 10K requests/ngày	Tránh mất $200-2000/tháng do lạm dụng
Doanh nghiệp vừa (20-50 users)	$200-500	Unlimited keys, team roles, Slack alerts	Tránh mất $1000-10000/tháng
Enterprise (100+ users)	Tùy chỉnh	SSO, compliance reports, SLA 99.9%	Compliance fines ($5000-50000) + leak prevention

Tính toán nhanh: Với HolySheep DeepSeek V3.2 ($0.42/MTok), nếu team 10 người mỗi người tiêu tốn trung bình 1M tokens/tháng, chi phí chỉ $4.20/người/tháng — rẻ hơn cả một ly cà phê.

Vì Sao Chọn HolySheep?

• Tiết kiệm 85%+: DeepSeek V3.2 chỉ $0.42/MTok so với $2.75-8 của OpenAI/Claude
• Tốc độ đỉnh <50ms: latency thấp hơn 60% so với direct API
• Tích hợp thanh toán Việt Nam: Hỗ trợ WeChat Pay, Alipay, và chuyển khoản nội địa
• Tín dụng miễn phí khi đăng ký: Bắt đầu test không rủi ro
• API compatible: Đổi sang HolySheep chỉ cần thay base URL từ api.openai.com sang api.holysheep.ai/v1

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

1. Lỗi: "Invalid API key" dù đã paste đúng

# Nguyên nhân thường gặp:
1. Copy thừa khoảng trắng ở đầu/cuối
2. Key bị expired hoặc bị revoke
3. Sai environment (dùng test key cho production)

Cách kiểm tra:
curl https://api.holysheep.ai/v1/models \
  -H "Authorization: Bearer YOUR_HOLYSHEEP_API_KEY"

Response thành công:
{
  "object": "list",
  "data": [
    {"id": "deepseek-v3.2", "object": "model"},
    {"id": "gemini-2.5-flash", "object": "model"}
  ]
}

Nếu lỗi 401 → Key không hợp lệ
Nếu lỗi 429 → Rate limit, chờ 60s rồi thử lại

2. Lỗi: Chi phí cao bất thường không rõ nguyên nhân

# Debug step-by-step:
1. Kiểm tra audit log gần đây
SELECT request_path, model, input_tokens, output_tokens, cost_usd, created_at
FROM audit_logs
WHERE created_at > NOW() - INTERVAL '1 hour'
ORDER BY cost_usd DESC
LIMIT 20;

2. Tìm user hoặc API key gây spike
SELECT ak.name, u.email, SUM(cost_usd) as total_cost, COUNT(*) as calls
FROM audit_logs al
JOIN api_keys ak ON al.api_key_id = ak.id
JOIN users u ON ak.user_id = u.id
WHERE al.created_at > NOW() - INTERVAL '24 hours'
GROUP BY ak.name, u.email
ORDER BY total_cost DESC;

3. Check prompt có bị recursive loop không
SELECT request_id, request_body 
FROM audit_logs
WHERE jsonb_array_length(request_body->'messages') > 50  -- Prompt quá dài
LIMIT 10;

3. Lỗi: Audit log không ghi hoặc ghi thiếu

# Kiểm tra buffer và flush process:
1. Xem buffer có đang chạy không
curl -X POST http://localhost:3000/admin/audit/debug

Response:
{
  "bufferSize": 15,
  "lastFlush": "2024-11-15T10:30:00Z",
  "flushErrors": 0
}

2. Manual flush nếu cần
curl -X POST http://localhost:3000/admin/audit/flush

3. Kiểm tra database connection
Thêm logging vào flush() function:
console.log(Flushing ${this.buffer.length} entries to database);

4. Nếu dùng serverless (Lambda/Vercel):
Buffer sẽ bị clear khi function terminate
→ Chuyển sang sync write hoặc dùng queue:
await auditLogger.log(entry);  // Sync write cho serverless

Tài nguyên liên quan

• 📚 Hướng dẫn AI API
• 💰 Xem giá
• 📖 Tài liệu nhà phát triển
• 🚀 Đăng ký miễn phí

Bài viết liên quan

• LLM API Price War: DeepSeek V3.2 $0.14/M Pricing Strategy An
• Hermes-Agent: Hướng Dẫn Triển Khai Doanh Nghiệp & Giám Sát T
• Tardis 数据转售服务：HolySheep 代理降低成本方案 — Từ $4,200 Xuống $680/Thán