HolySheep API中转站日志分析：ELK Stack集成实战

Bối cảnh thực chiến: Khi hệ thống AI thương mại điện tử "nghẹt thở"

Tôi vẫn nhớ rõ cái đêm tháng 11 năm 2025 - ngày Black Friday của năm đó. Hệ thống chatbot AI hỗ trợ khách hàng cho một sàn thương mại điện tử lớn tại Việt Nam bắt đầu trả về timeout liên tục. Độ trễ trung bình tăng từ 120ms lên... 8.5 giây. Đội ngũ DevOps không có cách nào debug được vì không ai biết chính xác request nào bị fail, thời điểm nào, và lý do tại sao.

Đó là lý do tôi bắt đầu xây dựng hệ thống log analysis với ELK Stack cho HolySheep API - nền tảng API AI trung gian mà đội ngũ đang sử dụng để kết nối với các mô hình GPT-4, Claude và Gemini. Kết quả? Sau 2 tuần triển khai, chúng tôi giảm 73% thời gian debug, phát hiện 3 bottleneck nghiêm trọng, và tiết kiệm khoảng $2,400 chi phí API mỗi tháng nhờ tối ưu prompt.

Tổng quan kiến trúc: Tại sao ELK Stack?

ELK Stack (Elasticsearch + Logstash + Kibana) là bộ ba công cụ mạnh mẽ nhất trong việc centralized logging. Khi kết hợp với HolySheep API, bạn có thể:

Thu thập log từ mọi request/response API
Tìm kiếm và phân tích patterns bất thường
Visualize chi phí theo thời gian thực
Cảnh báo tự động khi error rate vượt ngưỡng

Triển khai ELK Stack với Docker Compose

Đầu tiên, hãy thiết lập môi trường ELK Stack cục bộ. Tôi khuyên dùng Docker Compose để đảm bảo tính nhất quán giữa các môi trường.

version: '3.8'

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.11.0
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - "ES_JAVA_OPTS=-Xms2g -Xmx2g"
    ports:
      - "9200:9200"
    volumes:
      - es_data:/usr/share/elasticsearch/data
    networks:
      - elk
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:9200/_cluster/health || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5

  logstash:
    image: docker.elastic.co/logstash/logstash:8.11.0
    container_name: logstash
    volumes:
      - ./logstash/pipeline:/usr/share/logstash/pipeline:ro
      - ./logs:/var/log/holy-sheep:ro
    ports:
      - "5044:5044"
    environment:
      - "LS_JAVA_OPTS=-Xms512m -Xmx512m"
    networks:
      - elk
    depends_on:
      elasticsearch:
        condition: service_healthy

  kibana:
    image: docker.elastic.co/kibana/kibana:8.11.0
    container_name: kibana
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    networks:
      - elk
    depends_on:
      elasticsearch:
        condition: service_healthy

  filebeat:
    image: docker.elastic.co/beats/filebeat:8.11.0
    container_name: filebeat
    user: root
    volumes:
      - ./filebeat/filebeat.yml:/usr/share/filebeat/filebeat.yml:ro
      - ./logs:/var/log/holy-sheep:ro
    networks:
      - elk
    depends_on:
      - logstash

volumes:
  es_data:
    driver: local

networks:
  elk:
    driver: bridge

Chạy lệnh khởi động:

docker-compose up -d

Kiểm tra trạng thái các container
docker-compose ps

Output mong đợi:
NAME                COMMAND                  SERVICE             STATUS              PORTS
elasticsearch       "/bin/tini eswrapper…"   elasticsearch       running (healthy)   0.0.0.0:9200->9200/tcp
kibana              "/bin/tini -- /usr/l…"   kibana              running             0.0.0.0:5601->5601/tcp
logstash            "/usr/local/bin/dock…"   logstash            running             0.0.0.0:5044->5044/tcp
filebeat            "/usr/local/bin/dock…"   filebeat            running

HolySheep SDK với Logging tích hợp

Đây là phần quan trọng nhất - tôi đã viết một wrapper Python around HolySheep API với structured logging sẵn sàng cho ELK Stack.

# holy_sheep_client.py

import requests
import json
import logging
import time
from datetime import datetime
from typing import Optional, Dict, Any, List
from dataclasses import dataclass, asdict
import hashlib

Configure structured logging for ELK
logging.basicConfig(
    level=logging.INFO,
    format='%(message)s'
)
logger = logging.getLogger('holy_sheep')

@dataclass
class APILogEntry:
    timestamp: str
    request_id: str
    model: str
    prompt_tokens: int
    completion_tokens: int
    total_tokens: int
    latency_ms: float
    cost_usd: float
    status: str
    error_message: Optional[str]
    endpoint: str
    api_key_prefix: str

class HolySheepClient:
    BASE_URL = "https://api.holysheep.ai/v1"
    
    # Pricing per 1M tokens (USD) - Updated 2026
    PRICING = {
        "gpt-4.1": {"input": 2.00, "output": 6.00},
        "gpt-4.1-turbo": {"input": 1.00, "output": 4.00},
        "claude-sonnet-4.5": {"input": 3.00, "output": 12.00},
        "claude-opus-3.5": {"input": 15.00, "output": 75.00},
        "gemini-2.5-flash": {"input": 0.35, "output": 1.40},
        "gemini-2.5-pro": {"input": 1.25, "output": 5.00},
        "deepseek-v3.2": {"input": 0.07, "output": 0.28},
        "deepseek-chat": {"input": 0.14, "output": 0.28},
    }
    
    def __init__(self, api_key: str, log_file: str = "/var/log/holy-sheep/api.log"):
        self.api_key = api_key
        self.api_key_prefix = api_key[:8] + "***"
        self.log_file = log_file
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        })
        
    def _calculate_cost(self, model: str, usage: Dict) -> float:
        if model not in self.PRICING:
            return 0.0
        pricing = self.PRICING[model]
        input_cost = (usage.get("prompt_tokens", 0) / 1_000_000) * pricing["input"]
        output_cost = (usage.get("completion_tokens", 0) / 1_000_000) * pricing["output"]
        return round(input_cost + output_cost, 6)
    
    def _write_log(self, entry: APILogEntry):
        log_line = json.dumps(asdict(entry), ensure_ascii=False)
        logger.info(log_line)
        
        # Also write to file for Filebeat
        try:
            with open(self.log_file, 'a', encoding='utf-8') as f:
                f.write(log_line + '\n')
        except Exception as e:
            logger.error(f"Failed to write log: {e}")
    
    def chat_completion(
        self,
        model: str,
        messages: List[Dict[str, str]],
        temperature: float = 0.7,
        max_tokens: Optional[int] = None,
        **kwargs
    ) -> Dict[str, Any]:
        request_id = hashlib.md5(
            f"{datetime.utcnow().isoformat()}{model}".encode()
        ).hexdigest()[:16]
        
        start_time = time.perf_counter()
        
        payload = {
            "model": model,
            "messages": messages,
            "temperature": temperature,
        }
        if max_tokens:
            payload["max_tokens"] = max_tokens
        payload.update(kwargs)
        
        try:
            response = self.session.post(
                f"{self.BASE_URL}/chat/completions",
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            result = response.json()
            
            latency_ms = (time.perf_counter() - start_time) * 1000
            usage = result.get("usage", {})
            cost = self._calculate_cost(model, usage)
            
            log_entry = APILogEntry(
                timestamp=datetime.utcnow().isoformat() + "Z",
                request_id=request_id,
                model=model,
                prompt_tokens=usage.get("prompt_tokens", 0),
                completion_tokens=usage.get("completion_tokens", 0),
                total_tokens=usage.get("total_tokens", 0),
                latency_ms=round(latency_ms, 2),
                cost_usd=cost,
                status="success",
                error_message=None,
                endpoint="/v1/chat/completions",
                api_key_prefix=self.api_key_prefix
            )
            self._write_log(log_entry)
            
            return result
            
        except requests.exceptions.Timeout:
            latency_ms = (time.perf_counter() - start_time) * 1000
            log_entry = APILogEntry(
                timestamp=datetime.utcnow().isoformat() + "Z",
                request_id=request_id,
                model=model,
                prompt_tokens=0,
                completion_tokens=0,
                total_tokens=0,
                latency_ms=round(latency_ms, 2),
                cost_usd=0,
                status="timeout",
                error_message="Request timeout after 30s",
                endpoint="/v1/chat/completions",
                api_key_prefix=self.api_key_prefix
            )
            self._write_log(log_entry)
            raise
            
        except requests.exceptions.RequestException as e:
            latency_ms = (time.perf_counter() - start_time) * 1000
            log_entry = APILogEntry(
                timestamp=datetime.utcnow().isoformat() + "Z",
                request_id=request_id,
                model=model,
                prompt_tokens=0,
                completion_tokens=0,
                total_tokens=0,
                latency_ms=round(latency_ms, 2),
                cost_usd=0,
                status="error",
                error_message=str(e),
                endpoint="/v1/chat/completions",
                api_key_prefix=self.api_key_prefix
            )
            self._write_log(log_entry)
            raise

Ví dụ sử dụng
if __name__ == "__main__":
    client = HolySheepClient(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        log_file="./logs/api.log"
    )
    
    response = client.chat_completion(
        model="gpt-4.1-turbo",
        messages=[
            {"role": "system", "content": "Bạn là trợ lý AI cho sàn thương mại điện tử."},
            {"role": "user", "content": "Tìm kiếm sản phẩm iPhone 15 Pro Max giá tốt nhất"}
        ],
        temperature=0.7,
        max_tokens=500
    )
    
    print(f"Response: {response['choices'][0]['message']['content']}")
    print(f"Usage: {response['usage']}")

Cấu hình Filebeat cho HolySheep Logs

# filebeat/filebeat.yml

filebeat.inputs:
  - type: log
    enabled: true
    paths:
      - /var/log/holy-sheep/*.log
    json.keys_under_root: true
    json.add_error_key: true
    json.message_key: log
    fields:
      service: holy-sheep-api
      environment: production
    fields_under_root: true

processors:
  - add_host_metadata:
      when.not.contains.tags: forwarded
  - add_cloud_metadata: ~
  - add_docker_metadata: ~
  - timestamp:
      field: timestamp
      layouts:
        - '2006-01-02T15:04:05Z07:00'
      test:
        - '2025-11-29T10:30:00Z'
  - drop_fields:
      fields: ["log", "host", "agent", "ecs"]
      ignore_missing: true

output.logstash:
  hosts: ["logstash:5044"]
  
setup.kibana:
  host: "kibana:5601"

setup.ilm.enabled: auto
setup.ilm.rollover_alias: "holy-sheep-logs"
setup.ilm.pattern: "{now/d}-000001"
setup.ilm.policy_name: "holy-sheep-policy"

logging.level: info
logging.to_files: true
logging.files:
  path: /var/log/filebeat
  name: filebeat
  keepfiles: 7
  permissions: 0640

Logstash Pipeline: Parse và Enrich dữ liệu

# logstash/pipeline/holy-sheep.conf

input {
  beats {
    port => 5044
  }
}

filter {
  # Parse JSON từ log
  json {
    source => "message"
    target => "parsed"
  }
  
  # Extract các trường
  if [parsed][model] {
    mutate {
      add_field => {
        "model" => "%{[parsed][model]}"
        "request_id" => "%{[parsed][request_id]}"
        "latency_ms" => "%{[parsed][latency_ms]}"
        "cost_usd" => "%{[parsed][cost_usd]}"
        "status" => "%{[parsed][status]}"
        "prompt_tokens" => "%{[parsed][prompt_tokens]}"
        "completion_tokens" => "%{[parsed][completion_tokens]}"
      }
    }
    
    # Convert sang số
    mutate {
      convert => {
        "latency_ms" => "float"
        "cost_usd" => "float"
        "prompt_tokens" => "integer"
        "completion_tokens" => "integer"
      }
    }
  }
  
  # Tính toán các metrics bổ sung
  if [latency_ms] and [latency_ms] > 0 {
    ruby {
      code => '
        latency = event.get("latency_ms")
        
        # Phân loại latency
        if latency < 100
          event.set("latency_category", "excellent")
        elsif latency < 500
          event.set("latency_category", "good")
        elsif latency < 2000
          event.set("latency_category", "slow")
        else
          event.set("latency_category", "critical")
        end
        
        # Tính cost per token
        tokens = event.get("completion_tokens").to_f
        cost = event.get("cost_usd").to_f
        if tokens > 0
          event.set("cost_per_token", cost / tokens * 1000)
        end
      '
    }
  }
  
  # Thêm thông tin mô hình AI
  if [model] {
    if [model] =~ /gpt-4/ {
      mutate {
        add_field => {
          "model_family" => "OpenAI"
          "model_tier" => "premium"
        }
      }
    } else if [model] =~ /claude/ {
      mutate {
        add_field => {
          "model_family" => "Anthropic"
          "model_tier" => "premium"
        }
      }
    } else if [model] =~ /gemini/ {
      mutate {
        add_field => {
          "model_family" => "Google"
          "model_tier" => "standard"
        }
      }
    } else if [model] =~ /deepseek/ {
      mutate {
        add_field => {
          "model_family" => "DeepSeek"
          "model_tier" => "budget"
        }
      }
    }
  }
  
  # Đánh dấu errors
  if [status] == "error" or [status] == "timeout" {
    mutate {
      add_tag => ["problematic"]
    }
  }
  
  # Xử lý lỗi
  if [parsed][error_message] {
    mutate {
      add_field => {
        "error_type" => "%{[parsed][error_message]}"
      }
    }
  }
  
  # GeoIP lookup (nếu có IP)
  if [client_ip] {
    geoip {
      source => "client_ip"
      target => "geoip"
    }
  }
  
  # User agent parsing
  if [user_agent] {
    useragent {
      source => "user_agent"
      target => "ua"
    }
  }
  
  # Loại bỏ trường parsed gốc
  mutate {
    remove_field => ["parsed"]
  }
}

output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
    index => "holy-sheep-logs-%{+YYYY.MM.dd}"
    document_type => "_doc"
    
    # ILM Policy
    ilm_enabled => true
    ilm_rollover_alias => "holy-sheep-logs"
    ilm_pattern => "000001"
    ilm_policy => "holy-sheep-policy"
  }
  
  # Debug output (tắt khi production)
  # stdout { codec => rubydebug }
}

Tạo Dashboard Kibana cho HolySheep

Sau khi cấu hình xong, hãy tạo một số visualization quan trọng trong Kibana:

// 1. Tạo Index Pattern trong Kibana Dev Tools
PUT /_ilm/policy/holy-sheep-policy
{
  "policy": {
    "phases": {
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_age": "7d",
            "max_size": "50gb"
          },
          "set_priority": {
            "priority": 100
          }
        }
      },
      "warm": {
        "min_age": "30d",
        "actions": {
          "set_priority": {
            "priority": 50
          },
          "shrink": {
            "number_of_shards": 1
          }
        }
      },
      "delete": {
        "min_age": "90d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}

// 2. Tạo Index Template
PUT /_index_template/holy-sheep-template
{
  "index_patterns": ["holy-sheep-logs-*"],
  "template": {
    "settings": {
      "number_of_shards": 1,
      "number_of_replicas": 0,
      "index.lifecycle.name": "holy-sheep-policy"
    },
    "mappings": {
      "properties": {
        "timestamp": { "type": "date" },
        "request_id": { "type": "keyword" },
        "model": { "type": "keyword" },
        "model_family": { "type": "keyword" },
        "model_tier": { "type": "keyword" },
        "latency_ms": { "type": "float" },
        "latency_category": { "type": "keyword" },
        "cost_usd": { "type": "float" },
        "cost_per_token": { "type": "float" },
        "prompt_tokens": { "type": "integer" },
        "completion_tokens": { "type": "integer" },
        "total_tokens": { "type": "integer" },
        "status": { "type": "keyword" },
        "error_message": { "type": "text" },
        "endpoint": { "type": "keyword" },
        "api_key_prefix": { "type": "keyword" }
      }
    }
  }
}

// 3. Tạo Saved Search cho recent errors
POST /_scripts/painless/alert-threshold
{
  "script": {
    "lang": "painless",
    "source": """
      if (doc['status'].value != 'success') {
        return true;
      }
      return false;
    """
  }
}

// 4. Visualize: Chi phí theo model (Aggregation)
GET /holy-sheep-logs-*/_search
{
  "size": 0,
  "aggs": {
    "cost_by_model": {
      "terms": {
        "field": "model",
        "size": 20,
        "order": { "total_cost": "desc" }
      },
      "aggs": {
        "total_cost": {
          "sum": { "field": "cost_usd" }
        },
        "avg_cost": {
          "avg": { "field": "cost_usd" }
        },
        "request_count": {
          "value_count": { "field": "request_id" }
        }
      }
    },
    "cost_by_family": {
      "terms": {
        "field": "model_family"
      },
      "aggs": {
        "total_cost": {
          "sum": { "field": "cost_usd" }
        }
      }
    }
  }
}

// 5. Visualize: Latency distribution
GET /holy-sheep-logs-*/_search
{
  "size": 0,
  "aggs": {
    "latency_percentiles": {
      "percentiles": {
        "field": "latency_ms",
        "percents": [50, 90, 95, 99]
      }
    },
    "latency_histogram": {
      "histogram": {
        "field": "latency_ms",
        "interval": 100
      }
    }
  }
}

// 6. Visualize: Error rate over time
GET /holy-sheep-logs-*/_search
{
  "size": 0,
  "query": {
    "bool": {
      "filter": [
        { "range": { "@timestamp": { "gte": "now-24h" } } }
      ]
    }
  },
  "aggs": {
    "errors_over_time": {
      "date_histogram": {
        "field": "@timestamp",
        "fixed_interval": "5m"
      },
      "aggs": {
        "total_requests": {
          "value_count": { "field": "request_id" }
        },
        "failed_requests": {
          "filter": {
            "bool": {
              "must_not": [{ "term": { "status": "success" } }]
            }
          }
        },
        "error_rate": {
          "bucket_script": {
            "buckets_path": {
              "total": "total_requests",
              "failed": "failed_requests>_count"
            },
            "script": "(params.failed / params.total) * 100"
          }
        }
      }
    }
  }
}

Lỗi thường gặp và cách khắc phục

1. Lỗi "Connection refused" khi Filebeat gửi logs

Nguyên nhân: Filebeat khởi động trước Logstash, hoặc Logstash chưa sẵn sàng nhận kết nối.

# Cách khắc phục
Thêm healthcheck cho Logstash trong docker-compose.yml

services:
  logstash:
    # ... các config hiện tại ...
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9600/_node/stats"]
      interval: 10s
      timeout: 5s
      retries: 12

  filebeat:
    depends_on:
      logstash:
        condition: service_healthy

Hoặc thêm wait script trong entrypoint
wait-for-logstash.sh
#!/bin/bash
until curl -s http://logstash:9600/_node/stats > /dev/null; do
  echo "Waiting for Logstash..."
  sleep 5
done
echo "Logstash is ready!"

2. JSON parsing errors trong Logstash

Nguyên nhân: Log messages không đúng định dạng JSON, có thể do multi-line logs hoặc characters đặc biệt.

# Cách khắc phục - Cập nhật logstash pipeline

filter {
  # Thêm xử lý multi-line
  if [message] =~ /^\{/ {
    json {
      source => "message"
      target => "parsed"
      skip_on_invalid_json => true
    }
  } else {
    # Xử lý multi-line stack traces
    multiline {
      pattern => "^%{TIMESTAMP_ISO8601}"
      negate => true
      what => "previous"
    }
  }
  
  # Fallback: Nếu JSON parse fail, ghi lại raw message
  if ![parsed] {
    mutate {
      add_field => {
        "raw_message" => "%{message}"
        "parse_status" => "failed"
      }
    }
  }
}

Đảm bảo Python logger format đúng JSON
import logging
import json

class JSONFormatter(logging.Formatter):
    def format(self, record):
        log_data = {
            "timestamp": self.formatTime(record),
            "level": record.levelname,
            "logger": record.name,
            "message": record.getMessage(),
        }
        if record.exc_info:
            log_data["exception"] = self.formatException(record.exc_info)
        return json.dumps(log_data)

Sử dụng formatter
handler = logging.StreamHandler()
handler.setFormatter(JSONFormatter())

3. Out of Memory khi Elasticsearch indexing

Nguyên nhân: Volume logs quá lớn, ELK Stack không đủ resource.

# Cách khắc phục

1. Tăng JVM heap cho Elasticsearch
environment:
  - "ES_JAVA_OPTS=-Xms4g -Xmx4g"  # 50% RAM máy chủ

2. Thêm bulk indexing trong Logstash
output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
    manage_template => false
    index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
    
    # Bulk indexing settings
    flush_size => 5000
    idle_flush_time => 1s
    max_retries => 3
    
    # Document-level batching
    document_id => "%{request_id}"
  }
}

3. Thêm Filebeat bulk publishing
filebeat.inputs:
  - type: log
    paths:
      - /var/log/holy-sheep/*.log
    close_inactive: 5m
    ignore_older: 24h
    harvester_buffer_size: 16384
    
filebeat.shutdown_timeout: 5s

4. Monitoring memory
GET /_cat/nodes?v&h=name,heap.current,heap.percent,heap.max

4. Missing fields khi query trong Kibana

Nguyên nhân: Index template chưa được apply đúng hoặc mapping conflict.

# Cách khắc phục

1. Kiểm tra index hiện tại
GET /holy-sheep-logs-*/_mapping?pretty

2. Xóa index cũ và tạo lại
DELETE /holy-sheep-logs-*

3. Force reload template
POST /_index_template/holy-sheep-template/_reload

4. Verify template đã apply
GET /_index_template/holy-sheep-template

5. Nếu dùng ILM, tạo lifecycle policy trước
PUT _ilm/policy/holy-sheep-policy
{
  "policy": {
    "phases": {
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_age": "7d",
            "max_size": "50gb"
          }
        }
      }
    }
  }
}

6. Tạo initial index với alias
PUT holy-sheep-logs-000001
{
  "aliases": {
    "holy-sheep-logs": {}
  }
}

So sánh: ELK Stack vs các giải pháp khác

Tiêu chí	ELK Stack	Datadog	CloudWatch Logs	Grafana + Loki
Chi phí hàng tháng	Miễn phí (self-hosted)	$15/host/tháng trở lên	$0.50/GB ingestion	Miễn phí (self-hosted)
Setup phức tạp	Trung bình	Dễ	Dễ	Trung bình
Khả năng mở rộng	Rất cao	Rất cao	Cao	Rất cao
Tích hợp HolySheep	✓ Native JSON	✓ Agent có sẵn	✓ CloudWatch Agent	✓ Promtail
Query language	KQL + DSL	SQL-like	CloudWatch Insights	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 HolySheep API中转站熔断器模式： Chiến lược Service Degradation Toàn D Tardis加密货币数据API迁移全攻略：从噩梦到日赚斗金的技术复盘 Gemini 2.0 Flash API中转调用：多模态能力实测对比 🔥 Thử HolySheep AI Cổng AI API trực tiếp. Hỗ trợ Claude, GPT-5, Gemini, DeepSeek — một khóa, không cần VPN. 👉 Đăng ký miễn phí → © 2026 HolySheep AI · Thêm hướng dẫn

Bối cảnh thực chiến: Khi hệ thống AI thương mại điện tử "nghẹt thở"

Tổng quan kiến trúc: Tại sao ELK Stack?

Triển khai ELK Stack với Docker Compose

Kiểm tra trạng thái các container

Output mong đợi:

NAME COMMAND SERVICE STATUS PORTS

elasticsearch "/bin/tini eswrapper…" elasticsearch running (healthy) 0.0.0.0:9200->9200/tcp

kibana "/bin/tini -- /usr/l…" kibana running 0.0.0.0:5601->5601/tcp

logstash "/usr/local/bin/dock…" logstash running 0.0.0.0:5044->5044/tcp

filebeat "/usr/local/bin/dock…" filebeat running

HolySheep SDK với Logging tích hợp

Configure structured logging for ELK

Ví dụ sử dụng

Cấu hình Filebeat cho HolySheep Logs

Logstash Pipeline: Parse và Enrich dữ liệu

Tạo Dashboard Kibana cho HolySheep

Lỗi thường gặp và cách khắc phục

1. Lỗi "Connection refused" khi Filebeat gửi logs

Thêm healthcheck cho Logstash trong docker-compose.yml

Hoặc thêm wait script trong entrypoint

wait-for-logstash.sh

2. JSON parsing errors trong Logstash

Đảm bảo Python logger format đúng JSON

Sử dụng formatter

3. Out of Memory khi Elasticsearch indexing

1. Tăng JVM heap cho Elasticsearch

2. Thêm bulk indexing trong Logstash

3. Thêm Filebeat bulk publishing

4. Monitoring memory

4. Missing fields khi query trong Kibana

1. Kiểm tra index hiện tại

2. Xóa index cũ và tạo lại

3. Force reload template

4. Verify template đã apply

5. Nếu dùng ILM, tạo lifecycle policy trước

6. Tạo initial index với alias

So sánh: ELK Stack vs các giải pháp khác

Tài nguyên liên quan

Bài viết liên quan

🔥 Thử HolySheep AI

`filebeat "/usr/local/bin/dock…" filebeat running`