# docker-compose.monitoring.yaml
version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    ports:
      - "9100:9100"
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/'
    restart: unless-stopped

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    ports:
      - "9093:9093"
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
    restart: unless-stopped

volumes:
  prometheus-data:

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

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

  - job_name: 'node'
    static_configs:
      - targets: ['node-exporter:9100']

  - job_name: 'application'
    metrics_path: '/metrics'
    static_configs:
      - targets: ['app:8080']

# ai_predictor.py
import requests
from datetime import datetime, timedelta
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
import joblib

class VPSLoadPredictor:
    def __init__(self, prometheus_url="http://localhost:9090"):
        self.prom_url = prometheus_url
        self.model = None
        self.scaler = StandardScaler()
        self.is_trained = False

    def fetch_history(self, metric, hours=168):
        """Fetch historical data for a given metric from Prometheus"""
        end = datetime.now()
        start = end - timedelta(hours=hours)
        
        query = f'rate({metric}[5m])'
        url = f'{self.prom_url}/api/v1/query_range'
        
        params = {
            'query': query,
            'start': start.isoformat(),
            'end': end.isoformat(),
            'step': '300'  # 5-minute intervals
        }
        
        resp = requests.get(url, params=params)
        data = resp.json()['data']['result'][0]['values']
        
        timestamps = [datetime.fromisoformat(ts) for ts, _ in data]
        values = [float(v) for _, v in data]
        
        return timestamps, values

    def prepare_features(self, timestamps, values, forecast_hours=24):
        """Prepare prediction features: time features + statistical features"""
        features = []
        labels = []
        
        # Use past N days as training data
        window_size = 168  # Past week in hours
        
        for i in range(len(values) - window_size):
            window = values[i:i+window_size]
            
            # Statistical features
            features.append({
                'mean_7d': np.mean(window),
                'std_7d': np.std(window),
                'max_7d': np.max(window),
                'min_7d': np.min(window),
                'median_7d': np.median(window),
                # Time features
                'hour': timestamps[i+window_size-1].hour,
                'dayofweek': timestamps[i+window_size-1].weekday(),
                # Recent trend
                'trend_1h': np.mean(window[-6:]) - np.mean(window[-24:]),
                # Periodic features
                'hour_sin': np.sin(2 * np.pi * timestamps[i+window_size-1].hour / 24),
                'hour_cos': np.cos(2 * np.pi * timestamps[i+window_size-1].hour / 24),
            })
            
            # Label: average load in the next hour
            future_idx = i + window_size
            if future_idx < len(values):
                labels.append(np.mean(values[future_idx:future_idx+6]))
        
        return np.array(features), np.array(labels)

    def train(self):
        """Train the prediction model"""
        print("Fetching CPU load history...")
        timestamps, values = self.fetch_history('node_cpu_seconds_total', hours=168)
        
        print("Preparing features...")
        X, y = self.prepare_features(timestamps, values)
        
        print("Training model...")
        self.model = RandomForestRegressor(
            n_estimators=100,
            max_depth=15,
            min_samples_split=5,
            random_state=42
        )
        self.model.fit(self.scaler.fit_transform(X), y)
        self.is_trained = True
        
        # Save model
        joblib.dump(self.model, 'vps_predictor_model.pkl')
        joblib.dump(self.scaler, 'vps_predictor_scaler.pkl')
        print("Model trained and saved")

    def predict(self, hours_ahead=24):
        """Predict future load"""
        if not self.is_trained:
            self.train()
        
        # Get latest statistical features
        _, latest_values = self.fetch_history('node_cpu_seconds_total', hours=168)
        recent_window = latest_values[-168:]  # Past week
        
        # Build current time features
        now = datetime.now()
        current_features = [{
            'mean_7d': np.mean(recent_window),
            'std_7d': np.std(recent_window),
            'max_7d': np.max(recent_window),
            'min_7d': np.min(recent_window),
            'median_7d': np.median(recent_window),
            'hour': now.hour,
            'dayofweek': now.weekday(),
            'trend_1h': np.mean(recent_window[-6:]) - np.mean(recent_window[-24:]),
            'hour_sin': np.sin(2 * np.pi * now.hour / 24),
            'hour_cos': np.cos(2 * np.pi * now.hour / 24),
        }]
        
        X_pred = self.scaler.transform(current_features)
        predictions = self.model.predict(X_pred)
        
        return predictions[0]

# Install dependencies
pip install requests scikit-learn joblib numpy

# Train the model (requires 168 hours of historical data)
python3 ai_predictor.py train

# Run prediction
python3 ai_predictor.py predict

# decision_engine.py
from dataclasses import dataclass
from enum import Enum
from datetime import datetime

class Action(Enum):
    SCALE_UP = "scale_up"
    SCALE_DOWN = "scale_down"
    MAINTAIN = "maintain"
    EMERGENCY_SCALE = "emergency_scale"

@dataclass
class ScalingDecision:
    action: Action
    current_load: float
    predicted_load: float
    confidence: float
    recommended_instances: int
    reason: str
    cost_impact: float  # Estimated cost change ($/month)

class DecisionEngine:
    def __init__(self, config):
        self.config = config
        # Performance targets
        self.target_cpu_percent = config.get('target_cpu_percent', 60)
        self.min_instances = config.get('min_instances', 1)
        self.max_instances = config.get('max_instances', 10)
        # Cost constraints
        self.max_monthly_cost = config.get('max_monthly_cost', 500)
        self.cost_per_instance = config.get('cost_per_instance', 50)
        # Safety constraints
        self.emergency_threshold = config.get('emergency_threshold', 90)
        self.scale_down_cooldown = config.get('scale_down_cooldown', 300)

    def evaluate(self, current_load, predicted_load, confidence=0.85):
        """Generate scaling decisions based on current and predicted load"""
        
        # Emergency: immediate scale up
        if current_load > self.emergency_threshold:
            instances = min(
                int(current_load / self.target_cpu_percent) + 1,
                self.max_instances
            )
            return ScalingDecision(
                action=Action.EMERGENCY_SCALE,
                current_load=current_load,
                predicted_load=predicted_load,
                confidence=confidence,
                recommended_instances=instances,
                reason=f"Emergency scale-up: current CPU at {current_load:.1f}% exceeds emergency threshold {self.emergency_threshold}%",
                cost_impact=(instances - 1) * self.cost_per_instance
            )
        
        # Regular decision based on prediction
        effective_load = max(current_load, predicted_load * confidence)
        
        if effective_load > self.target_cpu_percent * 1.2:
            # Need to scale up
            needed = int(effective_load / self.target_cpu_percent) + 1
            # Check cost constraints
            needed = min(needed, self._get_max_affordable_instances())
            needed = min(needed, self.max_instances)
            
            return ScalingDecision(
                action=Action.SCALE_UP,
                current_load=current_load,
                predicted_load=predicted_load,
                confidence=confidence,
                recommended_instances=max(needed, 1),
                reason=f"Predicted load ({predicted_load:.1f}%) exceeds target ({self.target_cpu_percent}%), recommend scaling up",
                cost_impact=(needed - 1) * self.cost_per_instance
            )
        
        elif effective_load < self.target_cpu_percent * 0.4 and self._can_scale_down():
            # Can scale down
            needed = max(
                int(effective_load / self.target_cpu_percent) + 1,
                1
            )
            needed = max(needed, self.min_instances)
            
            return ScalingDecision(
                action=Action.SCALE_DOWN,
                current_load=current_load,
                predicted_load=predicted_load,
                confidence=confidence,
                recommended_instances=needed,
                reason=f"Idle load ({effective_load:.1f}%), recommend scaling down to {needed} instances",
                cost_impact=-(self._current_instances() - needed) * self.cost_per_instance
            )
        
        else:
            return ScalingDecision(
                action=Action.MAINTAIN,
                current_load=current_load,
                predicted_load=predicted_load,
                confidence=confidence,
                recommended_instances=self._current_instances(),
                reason=f"Stable load ({current_load:.1f}%), maintaining current configuration",
                cost_impact=0
            )

# docker-compose.autoscale.yml
version: '3.8'

services:
  web-app:
    image: your-app:latest
    deploy:
      replicas: 2
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.1'
          memory: 128M
      restart_policy:
        condition: on-failure
      update_config:
        parallelism: 1
        delay: 10s
    ports:
      - "8080:8080"
    networks:
      - app-network

  autoscaler:
    image: python:3.11-slim
    volumes:
      - ./autoscaler.py:/app/autoscaler.py
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - PROMETHEUS_URL=http://prometheus:9090
      - DECISION_INTERVAL=60
    depends_on:
      - prometheus
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

# autoscaler.py
import os
import time
import docker
import requests
from datetime import datetime

from ai_predictor import VPSLoadPredictor
from decision_engine import DecisionEngine

class DockerAutoScaler:
    def __init__(self):
        self.client = docker.from_env()
        self.predictor = VPSLoadPredictor(
            os.getenv('PROMETHEUS_URL', 'http://localhost:9090')
        )
        
        config = {
            'target_cpu_percent': 60,
            'min_instances': int(os.getenv('MIN_INSTANCES', '1')),
            'max_instances': int(os.getenv('MAX_INSTANCES', '5')),
            'max_monthly_cost': float(os.getenv('MAX_MONTHLY_COST', '300')),
            'cost_per_instance': float(os.getenv('COST_PER_INSTANCE', '50')),
            'emergency_threshold': float(os.getenv('EMERGENCY_THRESHOLD', '90')),
        }
        self.engine = DecisionEngine(config)

    def get_current_cpu_load(self):
        """Get current CPU load from Prometheus"""
        query = 'avg(rate(node_cpu_seconds_total{mode!="idle"}[5m])) * 100'
        
        resp = requests.get(
            f'{self.predictor.prom_url}/api/v1/query',
            params={'query': query}
        )
        data = resp.json()
        
        if data['data']['result']:
            return float(data['data']['result'][0]['value'][1])
        return 0

    def scale(self, decision):
        """Execute a scaling decision"""
        print(f"[{datetime.now()}] Executing: {decision.action.value}")
        print(f"  Reason: {decision.reason}")
        print(f"  Current instances: {self._current_replicas()}")
        print(f"  Target instances: {decision.recommended_instances}")
        
        current = self._current_replicas()
        target = decision.recommended_instances
        
        if target > current:
            for i in range(target - current):
                self._create_replica()
            print(f"  Scaled up by {target - current} instance(s)")
        elif target < current:
            for i in range(current - target):
                self._remove_replica()
            print(f"  Scaled down by {current - target} instance(s)")
        else:
            print(f"  No change needed, maintaining {current} instance(s)")

    def _current_replicas(self):
        try:
            service = self.client.services.get('web-app')
            return service.attrs['Spec']['Replicas'] or 1
        except Exception:
            return 1

    def run(self, interval=60):
        """Main loop"""
        print("AI Auto-Scaler started...")
        print(f"Decision interval: {interval}s")
        
        while True:
            try:
                current_load = self.get_current_cpu_load()
                print(f"\n[{datetime.now()}] Current CPU: {current_load:.1f}%")
                
                predicted_load = self.predictor.predict(hours_ahead=1)
                print(f"Predicted 1h load: {predicted_load:.1f}%")
                
                decision = self.engine.evaluate(current_load, predicted_load)
                self.scale(decision)
                
            except Exception as e:
                print(f"Auto-scaling error: {e}")
            
            time.sleep(interval)

# alerting.py
import os
import requests
from datetime import datetime

class AlertNotifier:
    def __init__(self):
        self.alert_history = []

    def notify(self, decision):
        """Send scaling decision notification"""
        message = {
            "text": f"Auto-scaling decision\n"
                    f"Action: {decision.action.value}\n"
                    f"Current load: {decision.current_load:.1f}%\n"
                    f"Predicted load: {decision.predicted_load:.1f}%\n"
                    f"Recommended instances: {decision.recommended_instances}\n"
                    f"Cost impact: ${decision.cost_impact:.2f}/month"
        }
        
        webhook_url = os.getenv('ALERT_WEBHOOK_URL')
        if webhook_url:
            requests.post(webhook_url, json=message)
        
        self.alert_history.append(message)
        print(f"Alert sent: {decision.action.value}")

def require_manual_approval(decision):
    """Emergency scale-ups or major changes require human approval"""
    if decision.action.value == 'emergency_scale':
        return True
    if decision.action.value == 'scale_up' and decision.recommended_instances > 3:
        return True
    return False