{
  "name": "Availability SLI",
  "type": "metric alert",
  "query": "sum(last_5m):sum:http.requests{status:200} / sum:http.requests{*} * 100 99.9",
  "message": "Availability has dropped below 99.9%",
  "tags": ["service:api", "env:production"],
  "options": {
    "thresholds": {
      "critical": 99.9
    }
  }
}

- El 99.95% de las solicitudes a la API REST serán exitosas (código 2xx) durante un período de 28 días
- El 99% de las solicitudes tendrán una latencia inferior a 300ms, medida durante un período de 30 días
- El tiempo de carga de la página principal será inferior a 2 segundos para el 95% de los usuarios durante una ventana móvil de 7 días

resource "google_monitoring_slo" "api_availability" {
  service = google_monitoring_service.api_service.id
  slo_id = "api-availability-slo"
  display_name = "API Availability SLO"
  
  goal = 0.995  # 99.5%
  rolling_period_days = 28
  
  request_based_sli {
    good_total_ratio {
      total_service_filter = "resource.type=cloud_run_revision AND resource.labels.service_name=api-service"
      good_service_filter = "resource.type=cloud_run_revision AND resource.labels.service_name=api-service AND metric.type=run.googleapis.com/request_count AND metric.labels.response_code_class!=5xx"
    }
  }
}

resource "google_monitoring_alert_policy" "slo_burn_rate_alert" {
  display_name = "SLO Burn Rate Alert"
  combiner = "OR"
  
  conditions {
    display_name = "Fast burn rate"
    condition_threshold {
      filter = "select_slo_burn_rate(\"${google_monitoring_slo.api_availability.id}\", \"1h\")"
      comparison = "COMPARISON_GT"
      threshold_value = 14.4  # Consumirá presupuesto en ~1 hora
      duration = "60s"
    }
  }
  
  conditions {
    display_name = "Slow burn rate"
    condition_threshold {
      filter = "select_slo_burn_rate(\"${google_monitoring_slo.api_availability.id}\", \"6h\")"
      comparison = "COMPARISON_GT"
      threshold_value = 3  # Consumirá presupuesto en ~24 horas
      duration = "600s"
    }
  }
  
  alert_strategy {
    notification_rate_limit {
      period = "300s"
    }
  }
  
  notification_channels = [
    google_monitoring_notification_channel.email.id,
    google_monitoring_notification_channel.slack.id
  ]
}

## SLI: [Nombre del SLI]

- **Descripción**: [Qué mide este SLI]
- **Fórmula**: [Cómo se calcula]
- **Fuente de datos**: [De dónde se obtienen los datos]
- **Frecuencia de medición**: [Cada cuánto se mide]
- **Responsable**: [Equipo/persona responsable]
- **Notas adicionales**: [Consideraciones especiales]

## SLI: Disponibilidad de API

- **Descripción**: Porcentaje de solicitudes exitosas (no 5xx)
- **Fórmula**: (Total de solicitudes - Solicitudes con errores 5xx) / Total de solicitudes × 100
- **Fuente de datos**: Logs de API Gateway + Prometheus
- **Frecuencia de medición**: Cada minuto, agregado por hora/día
- **Responsable**: Equipo de Plataforma
- **Notas adicionales**: Excluye endpoints de health check y readiness

## SLI: Latencia de API

- **Descripción**: Tiempo de respuesta para solicitudes a la API
- **Fórmula**: Percentil 95 del tiempo entre solicitud y respuesta completa
- **Fuente de datos**: Middleware de timing en aplicación
- **Frecuencia de medición**: Cada solicitud, agregado por minuto
- **Responsable**: Equipo de Backend
- **Notas adicionales**: Se mide en la capa de aplicación, no incluye latencia de red del cliente

import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats

# Cargar datos históricos de latencia (p95) por día
data = pd.read_csv('latency_p95_daily.csv')

# Calcular estadísticas
mean_latency = data['latency_ms'].mean()
percentile_99 = data['latency_ms'].quantile(0.99)
percentile_95 = data['latency_ms'].quantile(0.95)

# Visualizar distribución
plt.figure(figsize=(10, 6))
plt.hist(data['latency_ms'], bins=20, alpha=0.7)
plt.axvline(percentile_95, color='r', linestyle='--', label=f'95th percentile: {percentile_95:.1f}ms')
plt.axvline(mean_latency, color='g', linestyle='-', label=f'Mean: {mean_latency:.1f}ms')
plt.xlabel('Latencia P95 (ms)')
plt.ylabel('Frecuencia (días)')
plt.title('Distribución de Latencia P95 Diaria')
plt.legend()
plt.savefig('latency_distribution.png')

# Propuesta de SLO
proposed_slo = int(percentile_95 * 1.1)  # 10% margen sobre el p95 histórico
print(f"SLO propuesto: {proposed_slo}ms para el 95% de las solicitudes")

{
  "annotations": {
    "list": [
      {
        "builtIn": 1,
        "datasource": "-- Grafana --",
        "enable": true,
        "hide": true,
        "iconColor": "rgba(0, 211, 255, 1)",
        "name": "Annotations & Alerts",
        "type": "dashboard"
      },
      {
        "datasource": "Prometheus",
        "enable": true,
        "expr": "changes(slo_deployments_total[1m]) > 0",
        "iconColor": "rgba(255, 96, 96, 1)",
        "name": "Deployments",
        "titleFormat": "Deployment"
      }
    ]
  },
  "editable": true,
  "gnetId": null,
  "graphTooltip": 0,
  "id": 123,
  "iteration": 1597951492522,
  "links": [],
  "panels": [
    {
      "datasource": null,
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 0,
        "y": 0
      },
      "id": 2,
      "options": {
        "displayMode": "lcd",
        "orientation": "horizontal",
        "reduceOptions": {
          "calcs": [
            "lastNotNull"
          ],
          "fields": "",
          "values": false
        },
        "showUnfilled": true
      },
      "pluginVersion": "7.1.5",
      "targets": [
        {
          "expr": "slo:availability:ratio30d",
          "interval": "",
          "legendFormat": "Availability (30d)",
          "refId": "A"
        }
      ],
      "timeFrom": null,
      "timeShift": null,
      "title": "API Availability SLO (30d)",
      "type": "bargauge"
    },
    {
      "aliasColors": {},
      "bars": false,
      "dashLength": 10,
      "dashes": false,
      "datasource": null,
      "fieldConfig": {
        "defaults": {
          "custom": {}
        },
        "overrides": []
      },
      "fill": 1,
      "fillGradient": 0,
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 12,
        "y": 0
      },
      "hiddenSeries": false,
      "id": 4,
      "legend": {
        "avg": false,
        "current": false,
        "max": false,
        "min": false,
        "show": true,
        "total": false,
        "values": false
      },
      "lines": true,
      "linewidth": 1,
      "nullPointMode": "null",
      "percentage": false,
      "pluginVersion": "7.1.5",
      "pointradius": 2,
      "points": false,
      "renderer": "flot",
      "seriesOverrides": [
        {
          "alias": "SLO",
          "color": "#F2495C",
          "dashes": true,
          "fill": 0
        }
      ],
      "spaceLength": 10,
      "stack": false,
      "steppedLine": false,
      "targets": [
        {
          "expr": "slo:availability:ratio1h",
          "interval": "",
          "legendFormat": "Availability (1h)",
          "refId": "A"
        },
        {
          "expr": "0.995",
          "interval": "",
          "legendFormat": "SLO",
          "refId": "B"
        }
      ],
      "thresholds": [],
      "timeFrom": null,
      "timeRegions": [],
      "timeShift": null,
      "title": "API Availability (1h)",
      "tooltip": {
        "shared": true,
        "sort": 0,
        "value_type": "individual"
      },
      "type": "graph",
      "xaxis": {
        "buckets": null,
        "mode": "time",
        "name": null,
        "show": true,
        "values": []
      },
      "yaxes": [
        {
          "format": "percentunit",
          "label": null,
          "logBase": 1,
          "max": "1",
          "min": "0.99",
          "show": true
        },
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        }
      ],
      "yaxis": {
        "align": false,
        "alignLevel": null
      }
    }
  ],
  "schemaVersion": 26,
  "style": "dark",
  "tags": [
    "slo",
    "api"
  ],
  "templating": {
    "list": []
  },
  "time": {
    "from": "now-24h",
    "to": "now"
  },
  "timepicker": {},
  "timezone": "",
  "title": "API SLO Dashboard",
  "version": 1
}

# Informe de SLO - [Mes/Año]

## Resumen Ejecutivo
- SLOs cumplidos: X de Y (Z%)
- Incidentes significativos: N
- Presupuesto de error restante: XX%
## Detalles por Servicio

Este punto requiere consideración cuidadosa en la implementación.
### API
- **Disponibilidad**:
  - Objetivo: 99.95%
  - Actual: XX.XX%
  - Estado: ✅ Cumplido / ⚠️ En riesgo / ❌ Incumplido
  - Tendencia: ↑ Mejora / → Estable / ↓ Deterioro

- **Latencia**:
  - Objetivo: P95 300ms
  - Actual: XXXms
  - Estado: ✅ Cumplido / ⚠️ En riesgo / ❌ Incumplido
  - Tendencia: ↑ Mejora / → Estable / ↓ Deterioro

### [Otros servicios...]

Este punto requiere consideración cuidadosa en la implementación.
## Análisis de Incidentes
1. **Incidente #123** (2023-06-15)
   - Impacto: Aumento de latencia a >500ms durante 45 minutos
   - Causa raíz: Saturación de conexiones a base de datos
   - Acciones correctivas: Implementación de connection pooling mejorado

## Presupuesto de Error
- Presupuesto inicial: 1,000 errores
- Consumido este mes: 250 errores (25%)
- Acumulado anual: 3,200 errores (42.7%)
## Cambios Planificados
- Propuesta de ajuste SLO de latencia: 250ms → 200ms basado en mejoras recientes
- Nueva métrica SLI para tracking de éxito de transacciones

## Próximos Pasos
- Implementar alertas más granulares para detección temprana
- Revisar y actualizar presupuesto de error para Q3

# Ejemplo conceptual: Algoritmo de decisión para lanzamientos
def should_deploy_new_release():
    current_error_budget = get_current_error_budget()
    error_budget_threshold = 0.2  # 20% del presupuesto restante
    
    if current_error_budget error_budget_threshold:
        return False, "Error budget depleted, postpone non-critical releases"
    
    recent_incidents = get_incidents_last_7_days()
    if len(recent_incidents) >= 2:
        return False, "Multiple recent incidents, focus on stability"
    
    return True, "Sufficient error budget available for release"

public ProductResponse getProductDetails(String productId) {
    ProductDetails details;
    
    try {
        // Intento principal con timeout
        details = productService.getProduct(productId, 300, TimeUnit.MILLISECONDS);
    } catch (TimeoutException e) {
        // Degradación a caché con datos parcialmente actualizados
        details = productCache.getProduct(productId);
        metrics.incrementCounter("product_service_fallback");
    }
    
    PricingInfo pricing;
    try {
        // Intento principal con timeout más corto
        pricing = pricingService.getPricing(productId, 150, TimeUnit.MILLISECONDS);
    } catch (Exception e) {
        // Fallback a último precio conocido
        pricing = pricingCache.getLastKnownPricing(productId);
        metrics.incrementCounter("pricing_service_fallback");
    }
    
    // Incluso si fallan ambos servicios, devolvemos lo que tenemos
    return new ProductResponse(details, pricing);
}

// Ejemplo conceptual: SLO basado en Core Web Vitals
const webVitalsSLO = {
  name: "Core Web Vitals",
  description: "Experiencia de usuario óptima según estándares de Google",
  indicators: [
    {
      name: "LCP (Largest Contentful Paint)",
      target: "2.5s para el 75% de cargas de página",
      critical: true
    },
    {
      name: "FID (First Input Delay)",
      target: "100ms para el 90% de interacciones",
      critical: true
    },
    {
      name: "CLS (Cumulative Layout Shift)",
      target: "0.1 para el 80% de cargas de página",
      critical: false
    }
  ],
  business_impact: "Mejora de 15% en conversiones por cada 0.5s de mejora en LCP"
};

# Concepto: Sistema de SLO adaptativo con ML
class AdaptiveSLO:
    def __init__(self, service_name, initial_target=0.99):
        self.service_name = service_name
        self.current_target = initial_target
        self.model = load_prediction_model(f"models/{service_name}_slo_predictor.pkl")
        
    def predict_optimal_slo(self, recent_performance, upcoming_events):
        """Predice el SLO óptimo basado en datos recientes y eventos futuros"""
        features = self._extract_features(recent_performance, upcoming_events)
        predicted_slo = self.model.predict(features)[0]
        
        # Limitar cambios a incrementos razonables
        max_adjustment = 0.005  # Máximo 0.5% de cambio cada vez
        if abs(predicted_slo - self.current_target) > max_adjustment:
            direction = 1 if predicted_slo > self.current_target else -1
            predicted_slo = self.current_target + (direction * max_adjustment)
            
        return predicted_slo
        
    def update_slo(self):
        """Actualiza el SLO basado en predicciones y lo aplica"""
        recent_data = fetch_recent_performance(self.service_name, days=30)
        calendar_events = fetch_upcoming_events(days_ahead=14)
        
        new_target = self.predict_optimal_slo(recent_data, calendar_events)
        
        # Actualizar si el cambio es significativo
        if abs(new_target - self.current_target) >= 0.001:
            self.current_target = new_target
            apply_new_slo(self.service_name, new_target)
            log_slo_change(self.service_name, new_target, "ML-based adjustment")

# sloth - Ejemplo de SLO como código
version: "1.0"
service: "payment-api"
labels:
  team: "payments"
  tier: "1"
slos:
  - name: "availability"
    objective: 0.995
    description: "Proporción de solicitudes exitosas"
    sli:
      events:
        error_query: 'sum(rate(http_requests_total{job="payment-api",status=~"5.."}[{{.window}}]))'
        total_query: 'sum(rate(http_requests_total{job="payment-api"}[{{.window}}]))'
    alerting:
      name: "HighErrorRate"
      labels:
        severity: "page"
      annotations:
        summary: "Alta tasa de errores en la API de pagos"
        description: "La API de pagos está experimentando una tasa de errores superior al objetivo del SLO."
      page_alert:
        for: "5m"
        burn_rate_threshold: 14.4
      ticket_alert:
        for: "30m"
        burn_rate_threshold: 1