# pipeline de testing inteligente con GitHub Actions
name: Intelligent Testing
on: [push, pull_request]

jobs:
  unit-tests:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Generate unit tests with AI
      uses: codium-ai/action-generate-tests@v2
      with:
        api-key: ${{ secrets.CODIUM_API_KEY }}
        language: python
    - name: Run parallel unit tests
      run: |
        pytest tests/unit -n auto --cov=src --cov-report=xml

  integration-tests:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_PASSWORD: test
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
      redis:
        image: redis:7
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    steps:
    - uses: actions/checkout@v4
    - name: Run integration tests
      run: |
        pytest tests/integration -v

  e2e-tests:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Install Playwright
      run: npx playwright install --with-deps
    - name: Run E2E tests with visual AI
      run: |
        npx playwright test --grep @critical
    - name: Upload test results
      uses: actions/upload-artifact@v3
      if: always()
      with:
        name: playwright-report
        path: playwright-report/
        retention-days: 30

  flaky-test-detection:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Detect flaky tests
      uses: nick-fields/retry@v2
      with:
        timeout_minutes: 10
        max_attempts: 3
        command: pytest tests/ --tb=short

# OpenTelemetry auto-instrumentación completa
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
import logging

# Configurar tracing
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
    BatchSpanProcessor(OTLPSpanExporter(endpoint="http://jaeger:4317"))
)

# Instrumentación automática
FastAPIInstrumentor().instrument()
SQLAlchemyInstrumentor().instrument()

# Logs estructurados con contexto
import structlog
logger = structlog.get_logger()

def process_order(order_id):
    with trace.get_tracer(__name__).start_as_current_span("process_order") as span:
        span.set_attribute("order.id", order_id)
        span.set_attribute("order.value", calculate_value(order_id))
        
        logger.info("order.processing", order_id=order_id, status="started")
        # Business logic
        logger.info("order.completed", order_id=order_id, duration_ms=150)
        span.set_status(trace.Status(trace.StatusCode.OK))

# slo-definition.yaml (OpenSLO)
apiVersion: openslo/v1alpha
kind: SLO
metadata:
  name: api-availability
  displayName: API Availability
spec:
  description: Availability of the public API endpoints
  service: api-service
  indicator:
    ratioMetric:
      good:
        metricSource:
          type: prometheus
          spec:
            query: sum(rate(http_request_duration_seconds_count{status!~"5.."}[5m]))
      total:
        metricSource:
          type: prometheus
          spec:
            query: sum(rate(http_request_duration_seconds_count[5m]))
  objectives:
    - target: 0.995
      displayName: "99.5%"
      op: lte
  timeWindows:
    - calendar:
        timeZone: UTC
        startTime: "2026-01-01T00:00:00Z"
      count: 30
      isRolling: true

# Argo Rollouts - Canary analysis con métricas automáticas
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: myapp
spec:
  replicas: 10
  strategy:
    canary:
      steps:
      - setWeight: 20
      - pause:
          duration: 5m
      - analysis:
          templates:
          - templateName: success-rate
          args:
          - name: service-name
            value: myapp
      - setWeight: 50
      - pause:
          duration: 10m
      - analysis:
          templates:
          - templateName: latency-check
      - setWeight: 100
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:v2.0.0
        ports:
        - containerPort: 8080
---
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
  name: success-rate
spec:
  args:
  - name: service-name
  metrics:
  - name: success-rate
    interval: 2m
    count: 5
    successCondition: result[0] >= 0.99
    provider:
      prometheus:
        address: http://prometheus:9090
        query: |
          sum(rate(http_request_duration_seconds_count{service="{{args.service-name}}",status!~"5.."}[2m]))
          /
          sum(rate(http_request_duration_seconds_count{service="{{args.service-name}}"}[2m]))

# Pipeline DevSecOps completo
name: DevSecOps Pipeline
on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  sast:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: SAST with Semgrep
      uses: returntocorp/semgrep-action@v1
      with:
        config: p/ci
    - name: SAST with SonarQube
      uses: SonarSource/sonarqube-scan-action@v4
      env:
        SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

  sca:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: SCA with Snyk
      uses: snyk/actions/node@master
      env:
        SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
      with:
        args: --severity-threshold=high
    - name: License compliance
      uses: fossa/fossa-action@v1
      with:
        fossa-api-key: ${{ secrets.FOSSA_API_KEY }}

  secrets-detection:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Detect secrets with TruffleHog
      uses: trufflesecurity/trufflehog@main
      with:
        extra_args: --json --regex

  container-security:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Build Docker image
      run: docker build -t myapp:${{ github.sha }} .
    - name: Scan with Trivy
      uses: aquasecurity/trivy-action@master
      with:
        image-ref: myapp:${{ github.sha }}
        format: sarif
        output: trivy-results.sarif
    - name: Upload security results
      uses: github/codeql-action/upload-sarif@v2
      with:
        sarif_file: trivy-results.sarif

  infrastructure-security:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Terraform security scan
      uses: aquasecurity/tfsec@main
      with:
        soft_fail: true
    - name: Checkov
      uses: bridgecrewio/checkov-action@master
      with:
        directory: terraform/
        quiet: true

# Modelo de ML para predecir fallos (simplificado)
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from prometheus_api_client import PrometheusConnect

def train_failure_prediction():
    # Obtener métricas históricas
    prom = PrometheusConnect(url="http://prometheus:9090")
    cpu_query = 'rate(node_cpu_seconds_total[5m])'
    memory_query = 'node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes'
    
    df = pd.DataFrame({
        'cpu_usage': prom.custom_query(cpu_query),
        'memory_usage': prom.custom_query(memory_query),
        # ... más métricas
    })
    
    # Etiquetar fallos pasados
    df['failure_in_30min'] = get_failure_labels()
    
    # Entrenar modelo
    model = RandomForestClassifier(n_estimators=100)
    model.fit(df.drop('failure_in_30min', axis=1), df['failure_in_30min'])
    
    # Integrar en pipeline de alertas
    return model