# Prometheus metrics collection
from prometheus_client import Counter, Histogram, Gauge
import time

# Metrics
request_count = Counter('agent_requests_total', 'Total requests')
request_duration = Histogram('agent_request_duration_seconds', 'Request duration')
active_sessions = Gauge('agent_active_sessions', 'Active sessions')
token_usage = Counter('agent_tokens_used', 'Total tokens used')
error_count = Counter('agent_errors_total', 'Total errors', ['error_type'])

# Instrumentation
class MonitoredAgent:
    @request_duration.time()
    def process_request(self, request):
        request_count.inc()
        active_sessions.inc()
        
        try:
            # Process request
            response = self.agent.process(request)
            token_usage.inc(response.token_count)
            return response
        except Exception as e:
            error_count.labels(error_type=type(e).__name__).inc()
            raise
        finally:
            active_sessions.dec()

# Grafana dashboard config
dashboard_config = {
    "panels": [
        {
            "title": "Request Rate",
            "targets": [{"expr": "rate(agent_requests_total[5m])"}]
        },
        {
            "title": "Latency (P95)",
            "targets": [{"expr": "histogram_quantile(0.95, agent_request_duration_seconds)"}]
        },
        {
            "title": "Token Usage",
            "targets": [{"expr": "rate(agent_tokens_used[1h])"}]
        },
        {
            "title": "Error Rate",
            "targets": [{"expr": "rate(agent_errors_total[5m])"}]
        }
    ]
}

# Logging configuration
import structlog

logger = structlog.get_logger()

logger.info("agent_request",
    request_id=request.id,
    user_id=request.user_id,
    action=request.action,
    latency=response_time,
    tokens=token_count,
    cache_hit=cache_hit
)

# Distributed tracing with OpenTelemetry
from opentelemetry import trace
from opentelemetry.exporter.jaeger import JaegerExporter

tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("process_request") as span:
    span.set_attribute("request.id", request.id)
    span.set_attribute("model.name", model_name)
    # Process request
                

# Security middleware
from fastapi import FastAPI, Request, HTTPException
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import jwt
import redis
from typing import Optional

app = FastAPI()
security = HTTPBearer()
rate_limiter = redis.Redis()

# Rate limiting
async def rate_limit_check(request: Request):
    client_ip = request.client.host
    key = f"rate_limit:{client_ip}"
    
    try:
        requests = rate_limiter.incr(key)
        if requests == 1:
            rate_limiter.expire(key, 60)  # 1 minute window
        
        if requests > 100:  # 100 requests per minute
            raise HTTPException(status_code=429, detail="Rate limit exceeded")
    except redis.RedisError:
        pass  # Don't block on rate limit errors

# Authentication
async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
    token = credentials.credentials
    
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        return payload
    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="Token expired")
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")

# Input sanitization
def sanitize_input(text: str) -> str:
    # Remove potential injection attacks
    dangerous_patterns = [
        r'.*?',
        r'javascript:',
        r'on\w+\s*=',
        r'DROP TABLE',
        r'DELETE FROM'
    ]
    
    for pattern in dangerous_patterns:
        text = re.sub(pattern, '', text, flags=re.IGNORECASE)
    
    return text[:MAX_INPUT_LENGTH]  # Limit input length

# Audit logging
async def audit_log(request: Request, response: Response):
    log_entry = {
        "timestamp": datetime.utcnow().isoformat(),
        "ip": request.client.host,
        "method": request.method,
        "path": request.url.path,
        "status": response.status_code,
        "user_id": getattr(request.state, "user_id", None)
    }
    
    await audit_logger.log(log_entry)
                

# Blue-Green deployment script
#!/bin/bash

# Deploy to green environment
kubectl apply -f deployment-green.yaml

# Wait for green to be ready
kubectl wait --for=condition=ready pod -l version=green --timeout=300s

# Run smoke tests
./run-smoke-tests.sh green

if [ $? -eq 0 ]; then
    # Switch traffic to green
    kubectl patch service ai-agent-service -p '{"spec":{"selector":{"version":"green"}}}'
    
    # Wait and monitor
    sleep 60
    
    # If stable, remove blue
    kubectl delete deployment ai-agent-blue
    
    # Rename green to blue for next deployment
    kubectl patch deployment ai-agent-green -p '{"metadata":{"name":"ai-agent-blue"}}'
else
    echo "Smoke tests failed, rolling back"
    kubectl delete deployment ai-agent-green
fi
                

# Flagger canary configuration
apiVersion: flagger.app/v1beta1
kind: Canary
metadata:
  name: ai-agent
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: ai-agent
  progressDeadlineSeconds: 600
  service:
    port: 8000
  analysis:
    interval: 1m
    threshold: 5
    maxWeight: 50
    stepWeight: 10
    metrics:
    - name: request-success-rate
      thresholdRange:
        min: 99
      interval: 1m
    - name: request-duration
      thresholdRange:
        max: 500
      interval: 1m
    webhooks:
    - name: smoke-test
      url: http://flagger-loadtester/
      timeout: 30s
      metadata:
        type: smoke
        cmd: "curl -s http://ai-agent-canary:8000/health"