การ deploy AI service ขึ้น production ไม่ใช่แค่เรื่องของ model inference เท่านั้น แต่ต้องมี observability ที่ดีด้วย ในบทความนี้ผมจะสอนวิธีตั้งค่า Prometheus metrics สำหรับ AI service โดยเฉพาะ เน้นเรื่อง cost tracking และ performance monitoring ที่แม่นยำ

ทำไมต้องเก็บ Prometheus Metrics สำหรับ AI Service

AI service มีความแตกต่างจาก web service ทั่วไปตรงที่ cost per request สูงมาก เราต้องเก็บข้อมูล:

ราคา AI API 2026 สำหรับคำนวณ Cost

ModelOutput ($/MTok)10M tokens/เดือน
GPT-4.1$8.00$80.00
Claude Sonnet 4.5$15.00$150.00
Gemini 2.5 Flash$2.50$25.00
DeepSeek V3.2$0.42$4.20

ตารางนี้สำคัญมากสำหรับคำนวณ metrics ในโค้ดด้านล่าง

การติดตั้ง Prometheus Client Library

pip install prometheus-client flask requests

FastAPI + Prometheus Integration

import time
from prometheus_client import Counter, Histogram, Gauge, generate_latest, CONTENT_TYPE_LATEST
from flask import Flask, request, Response
import requests


สร้าง metrics registry

app = Flask(__name__)


=== AI Model Pricing 2026 ($/MTok) ===

MODEL_PRICING = {
    "gpt-4.1": {"output": 8.00},
    "claude-sonnet-4.5": {"output": 15.00},
    "gemini-2.5-flash": {"output": 2.50},
    "deepseek-v3.2": {"output": 0.42},
}


=== Prometheus Metrics ===

REQUEST_COUNT = Counter(
    'ai_request_total',
    'Total AI API requests',
    ['model', 'status']
)

TOKEN_USAGE = Counter(
    'ai_tokens_total',
    'Total tokens used',
    ['model', 'type']  # type: input, output
)

REQUEST_LATENCY = Histogram(
    'ai_request_duration_seconds',
    'AI request latency in seconds',
    ['model']
)

REQUEST_COST = Counter(
    'ai_request_cost_dollars',
    'Total cost in dollars',
    ['model']
)


Deep gauge for monitoring

ACTIVE_REQUESTS = Gauge(
    'ai_active_requests',
    'Number of active requests',
    ['model']
)

@app.route('/v1/chat/completions', methods=['POST'])
def chat_completions():
    start_time = time.time()
    ACTIVE_REQUESTS.labels(model='default').inc()
    
    try:
        data = request.json
        model = data.get('model', 'gpt-4.1')
        messages = data.get('messages', [])
        
        # === เรียก HolySheep AI API ===
        base_url = "https://api.holysheep.ai/v1"
        headers = {
            "Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",
            "Content-Type": "application/json"
        }
        payload = {
            "model": model,
            "messages": messages,
            "max_tokens": data.get('max_tokens', 1000)
        }
        
        response = requests.post(
            f"{base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=60
        )
        
        result = response.json()
        duration = time.time() - start_time
        
        # === Extract usage & calculate cost ===
        usage = result.get('usage', {})
        output_tokens = usage.get('completion_tokens', 1000)
        input_tokens = usage.get('prompt_tokens', 100)
        
        # Calculate cost
        price_per_mtok = MODEL_PRICING.get(model, MODEL_PRICING['gpt-4.1'])['output']
        cost = (output_tokens / 1_000_000) * price_per_mtok
        
        # === Update Prometheus Metrics ===
        REQUEST_COUNT.labels(model=model, status='success').inc()
        TOKEN_USAGE.labels(model=model, type='output').inc(output_tokens)
        REQUEST_LATENCY.labels(model=model).observe(duration)
        REQUEST_COST.labels(model=model).inc(cost)
        
        return Response(result, status=200)
        
    except Exception as e:
        REQUEST_COUNT.labels(model='default', status='error').inc()
        return Response(f'{{"error": "{str(e)}"}}', status=500, mimetype='application/json')
    
    finally:
        ACTIVE_REQUESTS.labels(model='default').dec()

@app.route('/metrics')
def metrics():
    return Response(generate_latest(), mimetype=CONTENT_TYPE_LATEST)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

การตั้งค่า prometheus.yml สำหรับ AI Service

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: []

rule_files: []

scrape_configs:
  - job_name: 'ai-service'
    static_configs:
      - targets: ['localhost:5000']
    metrics_path: '/metrics'
    scrape_interval: 5s  # AI service ควร scrape บ่อยกว่า

Dashboard Grafana สำหรับ Cost Monitoring

version: 2

panels:
  - title: "Total Cost ($/day)"
    type: graph
    targets:
      - expr: sum(increase(ai_request_cost_dollars[24h])) by (model)
    
  - title: "Token Usage Breakdown"
    type: piechart  
    targets:
      - expr: sum(ai_tokens_total) by (model, type)
    
  - title: "Latency P99"
    type: gauge
    targets:
      - expr: histogram_quantile(0.99, ai_request_duration_seconds)
    
  - title: "Cost Comparison: 10M tokens/month projection"
    type: bargauge
    targets:
      - expr: |
          10 * on(model) group_left(price)
          label_replace(
            ai_request_cost_dollars, 
            "model", "gpt-4.1", "", ""
          ) * 1000000 / 1

การ Monitor DeepSeek V3.2 ผ่าน HolySheep AI

สำหรับ HolySheep AI ผมใช้งานจริงพบว่า DeepSeek V3.2 ประหยัดมากที่สุด คือ $0.42/MTok ถ้าใช้ 10M tokens แค่ $4.20/เดือน เทียบกับ Claude ที่ $150/เดือน

import prometheus_client as pc


Custom metrics สำหรับ HolySheep API

HOLYSHEEP_COST = pc.Counter(
    'holysheep_cost_usd',
    'Cost in USD via HolySheep API',
    ['model']
)

HOLYSHEEP_LATENCY = pc.Histogram(
    'holysheep_latency_ms',
    'HolySheep API latency in milliseconds',
    ['model']
)

def call_holysheep(model: str, messages: list):
    """Wrapper สำหรับเรียก HolySheep API พร้อมเก็บ metrics"""
    import time
    import requests
    
    start = time.time()
    
    response = requests.post(
        "https://api.holysheep.ai/v1/chat/completions",
        headers={
            "Authorization": "Bearer YOUR_HOLYSHEEP_API_KEY",
            "Content-Type": "application/json"
        },
        json={
            "model": model,
            "messages": messages,
            "max_tokens": 2000
        }
    )
    
    # เก็บ latency
    latency_ms = (time.time() - start) * 1000
    HOLYSHEEP_LATENCY.labels(model=model).observe(latency_ms)
    
    # คำนวณและเก็บ cost
    result = response.json()
    output_tokens = result.get('usage', {}).get('completion_tokens', 0)
    price = MODEL_PRICING[model]['output']
    cost = (output_tokens / 1_000_000) * price
    
    HOLYSHEEP_COST.labels(model=model).inc(cost)
    
    return result


ตัวอย่างการใช้งาน

if __name__ == "__main__":
    result = call_holysheep(
        "deepseek-v3.2",
        [{"role": "user", "content": "ทดสอบ cost tracking"}]
    )
    print(f"Response: {result}")

การใช้ Grafana Alert สำหรับ Cost Control

groups:
  - name: ai_cost_alerts
    interval: 30s
    rules:
      - alert: HighDailyCost
        expr: sum(increase(ai_request_cost_dollars[1h])) > 10
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "AI Cost เกิน $10/ชั่วโมง"
          description: "Model {{ $labels.model }} ใช้ไป ${{ $value }}"
          
      - alert: LatencySpike
        expr: histogram_quantile(0.95, ai_request_duration_seconds) > 5
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Latency สูงกว่า 5 วินาที"
          
      - alert: BudgetExceeded
        expr: sum(increase(ai_request_cost_dollars[30d])) > 500
        labels:
          severity: critical
        annotations:
          summary: "เกินงบประมาณ $500/เดือน"

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

1. Prometheus ไม่ scrape metrics

สาเหตุ: Flask app ต้อง expose /metrics endpoint แต่บางครั้งใช้ route ผิด

# ❌ ผิด - ลืม route สำหรับ metrics
@app.route('/v1/chat/completions')
def chat():
    ...


✅ ถูกต้อง - เพิ่ม route /metrics

@app.route('/v1/chat/completions')
def chat():
    ...

@app.route('/metrics')
def metrics():
    return Response(generate_latest(), mimetype=CONTENT_TYPE_LATEST)

2. Token count ไม่ตรงกับ Invoice

สาเหตุ: ใช้ model name ไม่ตรงกับ pricing table หรือ API response format เปลี่ยน

# ❌ ผิด - hardcode ไม่ตรง
MODEL_PRICING = {
    "gpt-4": {"output": 30.00}  # model name ผิด, price ผิด
}


✅ ถูกต้อง - ตรวจสอบจาก API response

def extract_cost(result: dict, requested_model: str) -> float:
    usage = result.get('usage', {})
    output_tokens = usage.get('completion_tokens', 0)
    
    # ดึง actual model จาก response
    actual_model = result.get('model', requested_model)
    
    # Normalize model name
    normalized = actual_model.lower().replace('.', '-')
    
    price = MODEL_PRICING.get(normalized, {}).get('output', 8.00)
    return (output_tokens / 1_000_000) * price

3. Metric type ไม่เหมาะกับ use case

สาเหตุ: ใช้ Counter สำหรับค่าที่มีการ reset หรือใช้ Gauge สำหรับ cumulative value

# ❌ ผิด - ใช้ Gauge สำหรับ cumulative cost
COST_GAUGE = pc.Gauge('ai_cost', 'Total cost')  # reset เมื่อ restart


✅ ถูกต้อง - ใช้ Counter สำหรับ cumulative value

COST_COUNTER = pc.Counter('ai_cost_dollars', 'Total cost in dollars')

ข้อดี: Counter ไม่ reset เมื่อ restart, ใช้ increase() ได้เลย



สำหรับ rate และ increase ใช้ได้เลย

rate = COST_COUNTER.labels(model='gpt-4.1')

4. Memory leak จาก Label cardinality

สาเหตุ: ใช้ high-cardinality labels เช่น user_id, request_id

# ❌ ผิด - ใช้ user_id เป็น label (ห้ามทำ)
BAD_COUNTER = pc.Counter('requests', 'requests', ['user_id', 'request_id'])


✅ ถูกต้อง - ใช้แค่ low-cardinality labels

GOOD_COUNTER = pc.Counter('requests', 'requests', ['model', 'endpoint', 'status'])


ถ้าต้องการ track per user ใช้วิธีอื่น


เช่น push to time-series database หรือ log to file

สรุป

การเก็บ Prometheus metrics สำหรับ AI service ต้องคำนึงถึง cost tracking เป็นหลัก เพราะ AI API มีราคาสูง การ monitor ที่ดีช่วยให้:

สำหรับทีมที่ต้องการ ประหยัด 85%+ ลองใช้ HolySheep AI ที่ราคาเพียง $0.42/MTok สำหรับ DeepSeek V3.2 พร้อม latency <50ms และรองรับ WeChat/Alipay

👉 สมัคร HolySheep AI — รับเครดิตฟรีเมื่อลงทะเบียน

แหล่งข้อมูลที่เกี่ยวข้อง

บทความที่เกี่ยวข้อง