# Ejemplo simplificado de detección de anomalías con Prophet
from prophet import Prophet
import pandas as pd
import matplotlib.pyplot as plt

# Datos de CPU históricos
df = pd.DataFrame({
    'ds': pd.date_range(start='2025-01-01', periods=100, freq='H'),
    'y': [random.normalvariate(50, 10) for _ in range(100)]  # Valores normales
})

# Introducir anomalías
df.loc[80:85, 'y'] = 95  # Pico de CPU

# Ajustar modelo
model = Prophet(interval_width=0.99)
model.fit(df)

# Predecir valores esperados
forecast = model.predict(df)

# Identificar anomalías
anomalies = df.copy()
anomalies['forecast'] = forecast['yhat']
anomalies['anomaly'] = abs(anomalies['y'] - anomalies['forecast']) > forecast['yhat_upper'] - forecast['yhat']

# Visualizar
plt.figure(figsize=(15, 8))
plt.plot(df['ds'], df['y'], 'b-', label='Uso de CPU real')
plt.plot(forecast['ds'], forecast['yhat'], 'r-', label='Valor esperado')
plt.fill_between(forecast['ds'], forecast['yhat_lower'], forecast['yhat_upper'], color='gray', alpha=0.2, label='Intervalo de confianza')
plt.scatter(anomalies[anomalies['anomaly']]['ds'], anomalies[anomalies['anomaly']]['y'], color='red', s=50, label='Anomalías')
plt.legend()
plt.title('Detección de Anomalías en Uso de CPU')
plt.show()

# Ejemplo conceptual de análisis de causa raíz con grafos
import networkx as nx
import matplotlib.pyplot as plt

# Crear grafo de dependencias
G = nx.DiGraph()

# Añadir nodos (componentes del sistema)
components = ['Load Balancer', 'Web Server 1', 'Web Server 2', 'API Gateway', 
              'Auth Service', 'User Service', 'Database', 'Cache', 'Storage']
G.add_nodes_from(components)

# Añadir aristas (dependencias)
dependencies = [
    ('Load Balancer', 'Web Server 1'),
    ('Load Balancer', 'Web Server 2'),
    ('Web Server 1', 'API Gateway'),
    ('Web Server 2', 'API Gateway'),
    ('API Gateway', 'Auth Service'),
    ('API Gateway', 'User Service'),
    ('Auth Service', 'Database'),
    ('User Service', 'Database'),
    ('User Service', 'Cache'),
    ('User Service', 'Storage')
]
G.add_edges_from(dependencies)

# Simular componentes con fallos
failed_components = ['Database']
for component in failed_components:
    G.nodes[component]['status'] = 'failed'

# Propagar el impacto del fallo
impacted_components = []
for component in components:
    if component not in failed_components:
        paths = list(nx.algorithms.simple_paths.all_simple_paths(G, 'Database', component))
        if len(paths) > 0:
            impacted_components.append(component)
            G.nodes[component]['status'] = 'impacted'
    
# Visualizar el grafo
plt.figure(figsize=(12, 8))
pos = nx.spring_layout(G)
nx.draw_networkx_nodes(G, pos, 
                      nodelist=[n for n in G.nodes if n not in failed_components and n not in impacted_components],
                      node_color='green', node_size=500, alpha=0.8)
nx.draw_networkx_nodes(G, pos, 
                      nodelist=failed_components,
                      node_color='red', node_size=500, alpha=0.8)
nx.draw_networkx_nodes(G, pos, 
                      nodelist=impacted_components,
                      node_color='orange', node_size=500, alpha=0.8)
nx.draw_networkx_edges(G, pos, arrows=True)
nx.draw_networkx_labels(G, pos)
plt.title('Análisis de Impacto de Fallo en Base de Datos')
plt.axis('off')
plt.show()

# Ejemplo simplificado de clustering de alertas
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import DBSCAN
import pandas as pd
import numpy as np

# Datos de ejemplo: alertas de logs
alerts = [
    "Error connecting to database: connection refused",
    "Database connection error: network timeout",
    "Cannot establish connection to DB server",
    "Memory usage exceeded threshold on app server",
    "High memory consumption detected on web server",
    "Disk space critical on storage node",
    "Low disk space warning on file server",
    "API response time degraded",
    "Slow API performance detected"
]

# Convertir texto a vectores
vectorizer = TfidfVectorizer(stop_words='english')
X = vectorizer.fit_transform(alerts)

# Clustering con DBSCAN
clustering = DBSCAN(eps=0.5, min_samples=2).fit(X)

# Mostrar resultados
results = pd.DataFrame({
    'alert': alerts,
    'cluster': clustering.labels_
})

# Agrupar por cluster
for cluster_id in set(clustering.labels_):
    if cluster_id == -1:
        print("Alertas sin agrupar:")
    else:
        print(f"\nCluster {cluster_id} (tema probable: {', '.join([w for w, s in sorted(zip(vectorizer.get_feature_names_out(), np.mean(X[clustering.labels_ == cluster_id].toarray(), axis=0)), key=lambda x: x[1], reverse=True)[:3]])})")
    
    for alert in results[results['cluster'] == cluster_id]['alert']:
        print(f"  - {alert}")

# Ejemplo de predicción de fallos con serie temporal
import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA
import matplotlib.pyplot as plt

# Datos históricos de errores por día
dates = pd.date_range(start='2025-01-01', periods=60, freq='D')
errors = np.random.poisson(5, 60)  # Base de errores aleatorios
# Añadir tendencia creciente
for i in range(30, 60):
    errors[i] += int((i-30) * 0.5)  

error_data = pd.DataFrame({'date': dates, 'errors': errors})
error_data.set_index('date', inplace=True)

# Ajustar modelo ARIMA
model = ARIMA(error_data, order=(1, 1, 1))
model_fit = model.fit()

# Predecir próximos 14 días
forecast = model_fit.forecast(steps=14)
forecast_index = pd.date_range(start=error_data.index[-1] + pd.Timedelta(days=1), periods=14, freq='D')
forecast_series = pd.Series(forecast, index=forecast_index)

# Visualizar
plt.figure(figsize=(12, 6))
plt.plot(error_data, label='Errores históricos')
plt.plot(forecast_series, 'r--', label='Predicción')
plt.axhline(y=20, color='orange', linestyle='-.', label='Umbral crítico')
plt.title('Predicción de Tasa de Errores del Sistema')
plt.legend()
plt.xlabel('Fecha')
plt.ylabel('Número de errores')

# Identificar cuando se superará el umbral crítico
if any(forecast > 20):
    critical_date = forecast_series[forecast_series > 20].index[0]
    plt.annotate(f'Se supera umbral crítico: {critical_date.strftime("%Y-%m-%d")}',
                xy=(critical_date, forecast_series[critical_date]),
                xytext=(critical_date - pd.Timedelta(days=4), forecast_series[critical_date] + 5),
                arrowprops=dict(facecolor='black', shrink=0.05))
    print(f"¡Alerta! Se prevé que el sistema superará el umbral crítico de errores el {critical_date.strftime('%Y-%m-%d')}")
plt.show()

# Implementación de detección de anomalías con Prometheus y Python
import requests
import pandas as pd
import numpy as np
from sklearn.ensemble import IsolationForest
import time
import json

# Configuración
PROMETHEUS_URL = "http://prometheus.example.com:9090"
QUERY = 'rate(http_request_duration_seconds_sum{handler="/api/v1/users"}[5m]) / rate(http_request_duration_seconds_count{handler="/api/v1/users"}[5m])'
WINDOW = "1h"  # Ventana de datos históricos
LOOKBACK = 60  # Número de puntos de datos

# Función para obtener datos de Prometheus
def get_prometheus_data(query, window):
    response = requests.get(f"{PROMETHEUS_URL}/api/v1/query_range", 
                           params={
                               "query": query,
                               "start": int(time.time() - 3600),
                               "end": int(time.time()),
                               "step": "60s"
                           })
    
    if response.status_code != 200:
        raise Exception(f"Error querying Prometheus: {response.status_code}")
        
    data = response.json()
    if data["status"] != "success" or not data["data"]["result"]:
        raise Exception("No data returned from Prometheus")
    
    # Extraer valores de respuesta
    result = data["data"]["result"][0]
    values = [(float(v[1])) for v in result["values"]]
    timestamps = [v[0] for v in result["values"]]
    
    return pd.DataFrame({
        "timestamp": timestamps,
        "latency": values
    })

# Función para detectar anomalías
def detect_anomalies(data):
    # Usar IsolationForest para detectar anomalías
    model = IsolationForest(contamination=0.05, random_state=42)
    
    # Transformar datos para el modelo
    X = data["latency"].values.reshape(-1, 1)
    
    # Entrenar modelo y predecir
    predictions = model.fit_predict(X)
    
    # -1 indica anomalía, 1 indica normal
    data["anomaly"] = np.where(predictions == -1, True, False)
    
    return data

# Función principal
def main():
    try:
        # Obtener datos
        print("Obteniendo datos de Prometheus...")
        data = get_prometheus_data(QUERY, WINDOW)
        
        if len(data) LOOKBACK:
            print(f"Datos insuficientes. Se esperaban {LOOKBACK} puntos, se obtuvieron {len(data)}")
            return
        
        # Detectar anomalías
        print("Analizando datos en busca de anomalías...")
        result = detect_anomalies(data)
        
        # Reportar resultados
        anomalies = result[result["anomaly"] == True]
        if len(anomalies) > 0:
            print(f"Se detectaron {len(anomalies)} anomalías en la latencia de API:")
            for _, row in anomalies.iterrows():
                timestamp = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(row["timestamp"]))
                print(f"  - {timestamp}: {row['latency']:.4f}s (umbral normal: {result['latency'].mean():.4f}s)")
            
            # Aquí podríamos enviar alertas o activar automatizaciones
            alert_payload = {
                "summary": f"Detectadas {len(anomalies)} anomalías en latencia de API",
                "description": f"La API /api/v1/users está experimentando latencias anómalas. Valor medio: {result['latency'].mean():.4f}s, Valor máximo detectado: {anomalies['latency'].max():.4f}s",
                "severity": "warning" if len(anomalies) 3 else "critical"
            }
            
            print(f"Enviando alerta: {json.dumps(alert_payload, indent=2)}")
            # Aquí código para enviar a sistema de alertas
            
        else:
            print("No se detectaron anomalías en la latencia de API")
            
    except Exception as e:
        print(f"Error: {str(e)}")

if __name__ == "__main__":
    main()

# Pseudocódigo conceptual basado en la aproximación de Netflix
class PredictiveIncidentDetection:
    def __init__(self, thresholds):
        self.model = self._load_trained_model()
        self.thresholds = thresholds
        
    def _load_trained_model(self):
        # Cargar modelo pre-entrenado (LSTM, Random Forest, etc.)
        return load_model("path/to/model")
        
    def predict_incidents(self, metrics_window):
        # Extraer características relevantes
        features = self._extract_features(metrics_window)
        
        # Predicción de probabilidad de incidente
        incident_probability = self.model.predict_proba(features)[0][1]
        
        # Determinar nivel de severidad
        if incident_probability > self.thresholds["critical"]:
            return {"prediction": "critical", "probability": incident_probability, 
                   "time_to_incident": self._estimate_time_to_incident(features)}
        elif incident_probability > self.thresholds["warning"]:
            return {"prediction": "warning", "probability": incident_probability,
                   "time_to_incident": self._estimate_time_to_incident(features)}
        else:
            return {"prediction": "normal", "probability": incident_probability}
    
    def _extract_features(self, metrics_window):
        # Extraer características temporales, estadísticas, etc.
        features = []
        # . procesamiento de características .
        return features
        
    def _estimate_time_to_incident(self, features):
        # Estimar tiempo hasta el incidente
        # . lógica de estimación .
        return estimated_hours

# Ejemplo de configuración de monitoreo basado en ML para microservicios
microservices_monitoring:
  collection:
    metrics:
      - name: request_latency
        sampling_rate: 100%
      - name: error_rate
        sampling_rate: 100%
      - name: throughput
        sampling_rate: 100%
    traces:
      enabled: true
      sampling_rate: 10%
    logs:
      enabled: true
      level: INFO
      
  analysis:
    anomaly_detection:
      algorithms:
        - type: isolation_forest
          sensitivity: medium
        - type: lstm_autoencoder
          sensitivity: high
      dimensions:
        - service
        - endpoint
        - datacenter
      baseline_window: 14d
      
  alerting:
    standard_alerts:
      - name: high_error_rate
        threshold: 5%
        duration: 5m
    ml_alerts:
      - name: latency_anomaly
        confidence_threshold: 80%
        silence_learning_period: 7d
    
  automation:
    remediations:
      - trigger: high_error_rate
        action: scale_up
        approval: auto
      - trigger: latency_anomaly
        action: reroute_traffic
        approval: manual

# Ejemplo conceptual de clasificación de tickets con NLP
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
import numpy as np
import pickle

class TicketClassifier:
    def __init__(self, model_path, vectorizer_path):
        # Cargar modelo y vectorizador pre-entrenados
        with open(model_path, 'rb') as f:
            self.model = pickle.load(f)
        with open(vectorizer_path, 'rb') as f:
            self.vectorizer = pickle.load(f)
            
        # Mapeo de categorías
        self.categories = {
            0: {"team": "network", "priority": "medium"},
            1: {"team": "database", "priority": "high"},
            2: {"team": "application", "priority": "medium"},
            3: {"team": "security", "priority": "critical"},
            4: {"team": "infrastructure", "priority": "low"}
        }
        
    def classify_ticket(self, ticket_text):
        # Vectorizar texto
        features = self.vectorizer.transform([ticket_text])
        
        # Predecir categoría
        category_id = self.model.predict(features)[0]
        category_probs = self.model.predict_proba(features)[0]
        confidence = category_probs[category_id]
        
        # Obtener metadatos de la categoría
        category_info = self.categories[category_id]
        
        # Ajustar prioridad basada en palabras clave de urgencia
        urgency_keywords = ["urgent", "critical", "down", "crashed", "unavailable", "emergency"]
        if any(keyword in ticket_text.lower() for keyword in urgency_keywords):
            if category_info["priority"] != "critical":
                category_info["priority"] = "high"
                
        return {
            "team": category_info["team"],
            "priority": category_info["priority"],
            "confidence": confidence,
            "requires_human_review": confidence 0.7
        }
        
    def suggest_solutions(self, ticket_text, top_n=3):
        # Vectorizar texto
        features = self.vectorizer.transform([ticket_text])
        
        # Buscar tickets similares en base de conocimiento
        # . (lógica para recuperar tickets similares) .
        
        return [
            {"solution": "Restart the application service", "confidence": 0.85},
            {"solution": "Check network connectivity to database", "confidence": 0.72},
            {"solution": "Verify firewall rules for the affected service", "confidence": 0.65}
        ]

# Pseudocódigo para optimización de capacidad con ML
class CapacityOptimizer:
    def __init__(self):
        self.prediction_model = self._load_prediction_model()
        self.cost_model = self._load_cost_model()
        
    def optimize_capacity(self, service_id, forecasting_window=24):
        # Obtener datos históricos de uso
        historical_usage = self._get_historical_metrics(service_id)
        
        # Predecir uso futuro
        predicted_usage = self.prediction_model.predict(
            historical_usage, 
            horizon=forecasting_window
        )
        
        # Calcular capacidad óptima por hora
        optimal_capacity = []
        for hour in range(forecasting_window):
            # Añadir margen de seguridad basado en variabilidad
            predicted_load = predicted_usage[hour]
            prediction_stddev = self._get_prediction_uncertainty(predicted_load)
            
            # Capacidad base + margen de seguridad
            capacity = predicted_load * 1.1 + prediction_stddev * 2
            
            # Considerar restricciones específicas del servicio
            capacity = self._apply_service_constraints(service_id, capacity)
            
            optimal_capacity.append({
                "hour": hour,
                "predicted_load": predicted_load,
                "recommended_capacity": capacity,
                "confidence": self._calculate_confidence(prediction_stddev, predicted_load)
            })
        
        # Calcular ahorro estimado
        current_capacity = self._get_current_capacity(service_id)
        estimated_savings = self._calculate_savings(current_capacity, optimal_capacity)
        
        return {
            "service_id": service_id,
            "hourly_recommendations": optimal_capacity,
            "estimated_savings": estimated_savings,
            "risk_level": self._calculate_risk_level(optimal_capacity)
        }