# docker-compose.monitoring.yml
version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=7d'
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana

  node-exporter:
    image: prom/node-exporter:latest
    network_mode: host
    pid: host

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    network_mode: host
    volumes:
      - /:/rootfs:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro
    privileged: true
    devices:
      - /dev/kmsg

volumes:
  prometheus-data:
  grafana-data:

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets: ['localhost:9100']

  - job_name: 'cadvisor'
    static_configs:
      - targets: ['localhost:8080']

  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

import requests
from datetime import datetime, timedelta

def get_performance_snapshot(minutes=30):
    """Get aggregated performance metrics for the last N minutes"""
    end = datetime.now()
    start = end - timedelta(minutes=minutes)
    
    queries = {
        "cpu_usage": '100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[5m]) * 100) by (instance))',
        "memory_usage": '(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100',
        "disk_io": 'rate(node_disk_io_time_seconds_total[5m])',
        "network_rx": 'rate(node_network_receive_bytes_total[5m])',
        "network_tx": 'rate(node_network_transmit_bytes_total[5m])',
        "container_cpu": 'rate(container_cpu_usage_seconds_total[5m])',
        "container_memory": 'container_memory_usage_bytes / container_spec_memory_limit_bytes * 100',
        "load_avg_1m": 'node_load1',
        "load_avg_5m": 'node_load5',
        "load_avg_15m": 'node_load15',
        "swap_usage": '(node_memory_SwapTotal_bytes - node_memory_SwapFree_bytes) / node_memory_SwapTotal_bytes * 100',
        "fd_usage": 'node_filefd_allocated / node_filefd_maximum * 100',
    }
    
    snapshot = {}
    for name, query in queries.items():
        try:
            url = f"http://localhost:9090/api/v1/query_range"
            params = {"query": query, "start": start.timestamp(), "end": end.timestamp(), "step": "60"}
            resp = requests.get(url, params=params, timeout=10)
            data = resp.json()
            if data["status"] == "success" and data["data"]["result"]:
                values = [point[1] for point in data["data"]["result"][0]["values"]]
                snapshot[name] = {
                    "avg": sum(values) / len(values) if values else 0,
                    "max": max(values) if values else 0,
                    "min": min(values) if values else 0,
                    "current": values[-1] if values else 0,
                }
        except Exception as e:
            snapshot[name] = {"error": str(e)}
    
    return snapshot

import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

SYSTEM_PROMPT = """You are a senior Linux system performance expert.
Your task is to diagnose potential performance bottlenecks based on VPS performance data and provide actionable optimization recommendations.

Output format requirements:
1. **Problem Diagnosis**: Briefly describe the performance issues found
2. **Root Cause Analysis**: Analyze possible root causes
3. **Optimization Recommendations**: Provide specific tuning measures (with exact parameters and values)
4. **Risk Level**: Low / Medium / High
5. **Expected Impact**: Metrics that may improve after optimization

Please output in structured JSON format."""

def analyze_and_optimize(perf_snapshot):
    """AI analyzes performance data and generates optimization suggestions"""
    
    context = {
        "timestamp": datetime.now().isoformat(),
        "metrics": perf_snapshot,
        "system_info": {
            "cpu_cores": "auto",
            "total_memory_gb": "auto",
            "os": "Linux",
        }
    }
    
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {
            "role": "user",
            "content": json.dumps(context, indent=2, ensure_ascii=False)
        }
    ]
    
    response = client.chat.completions.create(
        model="llama3.2",  # or qwen2.5, minicpm-v, etc.
        messages=messages,
        temperature=0.3,
        max_tokens=2048,
    )
    
    suggestion = response.choices[0].message.content
    
    try:
        json_start = suggestion.find('{')
        json_end = suggestion.rfind('}') + 1
        if json_start >= 0 and json_end > json_start:
            return json.loads(suggestion[json_start:json_end])
        return {"raw": suggestion}
    except json.JSONDecodeError:
        return {"raw": suggestion}

import subprocess
import os

class AutoOptimizer:
    """Execute optimizations based on AI suggestions"""
    
    def __init__(self, dry_run=True):
        self.dry_run = dry_run  # Production: start with dry_run
        self.changelog = []
    
    def adjust_sysctl(self, params: dict):
        """Adjust /etc/sysctl.conf parameters"""
        for key, value in params.items():
            cmd = f"sysctl -w {key}={value}"
            if not self.dry_run:
                subprocess.run(cmd, shell=True, check=True)
            self.changelog.append(f"sysctl: {key} = {value}")
    
    def optimize_nginx(self, config_overrides: dict):
        """Optimize Nginx configuration"""
        config_path = "/etc/nginx/nginx.conf"
        current = open(config_path).read()
        
        for directive, value in config_overrides.items():
            pass  # Implement config replacement logic
        
        if not self.dry_run:
            with open(config_path, 'w') as f:
                f.write(current)
            subprocess.run("nginx -t && nginx -s reload", shell=True, check=True)
    
    def optimize_mysql(self, params: dict):
        """Optimize MySQL configuration"""
        mysql_conf = "/etc/mysql/mysql.conf.d/custom.cnf"
        
        with open(mysql_conf, 'a') as f:
            f.write("\n[mysqld]\n")
            for key, value in params.items():
                f.write(f"{key} = {value}\n")
        
        if not self.dry_run:
            subprocess.run("systemctl restart mysql", shell=True, check=True)
    
    def optimize_docker_resources(self, container_name: str, limits: dict):
        """Adjust Docker container resource limits"""
        if not self.dry_run:
            cmd = f"docker update --cpus={limits.get('cpus', '1.0')} "
            cmd += f"--memory={limits.get('memory', '512m')} {container_name}"
            subprocess.run(cmd, shell=True, check=True)
    
    def execute_suggestions(self, ai_suggestions: dict):
        """Execute AI-generated optimization suggestions"""
        actions = ai_suggestions.get("actions", [])
        
        for action in actions:
            action_type = action.get("type")
            
            if action_type == "sysctl":
                self.adjust_sysctl(action.get("params", {}))
            elif action_type == "nginx":
                self.optimize_nginx(action.get("params", {}))
            elif action_type == "mysql":
                self.optimize_mysql(action.get("params", {}))
            elif action_type == "docker":
                self.optimize_docker_resources(
                    action.get("container", ""),
                    action.get("limits", {})
                )
        
        return self.changelog

# /etc/cron.d/ai-performance-tuning
# Run performance analysis and tuning every 6 hours
0 */6 * * * root /usr/local/bin/ai-performance-tuning.sh

#!/bin/bash
# /usr/local/bin/ai-performance-tuning.sh

LOG_FILE="/var/log/ai-performance-tuning.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

echo "[$TIMESTAMP] Starting AI performance analysis and tuning..." >> "$LOG_FILE"

python3 /opt/ai-tuner/optimize.py >> "$LOG_FILE" 2>&1

echo "[$TIMESTAMP] Complete" >> "$LOG_FILE"

# Score each suggestion, prioritize low-risk/high-impact ones
def prioritize_suggestions(suggestions):
    for s in suggestions:
        if s["risk"] == "low" and s["expected_impact"] == "high":
            s["priority"] = 1  # Execute immediately
        elif s["risk"] == "low" and s["expected_impact"] == "medium":
            s["priority"] = 2  # Next maintenance window
        elif s["risk"] == "high":
            s["priority"] = 3  # Requires manual review
    return sorted(suggestions, key=lambda x: x["priority"])

def build_optimization_knowledge(base_snapshot, after_snapshot, suggestion):
    """Compare pre/post metrics to build knowledge base"""
    improvement = {}
    for metric in base_snapshot:
        if metric in after_snapshot:
            base_val = base_snapshot[metric]["avg"]
            after_val = after_snapshot[metric]["avg"]
            improvement[metric] = (after_val - base_val) / base_val * 100
    
    return {
        "suggestion": suggestion,
        "improvement": improvement,
        "timestamp": datetime.now().isoformat()
    }