// Ejemplo: Instrumentación de métricas con Micrometer en Spring Boot
@RestController
public class OrderController {
    private final Counter orderCounter;
    private final Timer orderProcessingTimer;
    
    public OrderController(MeterRegistry registry) {
        this.orderCounter = registry.counter("orders.created");
        this.orderProcessingTimer = registry.timer("orders.processing.time");
    }
    
    @PostMapping("/orders")
    public ResponseEntity<Order> createOrder(@RequestBody Order order) {
        return orderProcessingTimer.record(() -> {
            // Lógica para crear la orden
            orderCounter.increment();
            return ResponseEntity.ok(orderService.createOrder(order));
        });
    }
}

// Ejemplo: Logs estructurados en Node.js con Winston
const winston = require('winston');
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  defaultMeta: { service: 'payment-service' },
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

function processPayment(paymentId, amount, userId) {
  logger.info('Processing payment', {
    paymentId,
    amount,
    userId,
    timestamp: new Date().toISOString(),
    correlationId: getCurrentRequestId()
  });
  
  try {
    // Lógica de procesamiento de pago
    return result;
  } catch (error) {
    logger.error('Payment processing failed', {
      paymentId,
      errorCode: error.code,
      errorMessage: error.message,
      stack: error.stack,
      correlationId: getCurrentRequestId()
    });
    throw error;
  }
}

# Ejemplo: Tracing con OpenTelemetry en Python
from opentelemetry import trace
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.sdk.resources import SERVICE_NAME, Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

# Configurar el proveedor de trazas
resource = Resource(attributes={SERVICE_NAME: "inventory-service"})
provider = TracerProvider(resource=resource)
jaeger_exporter = JaegerExporter(
    agent_host_name="jaeger",
    agent_port=6831,
)
processor = BatchSpanProcessor(jaeger_exporter)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

tracer = trace.get_tracer(__name__)

def check_inventory(product_id, quantity):
    with tracer.start_as_current_span("check_inventory") as span:
        span.set_attribute("product_id", product_id)
        span.set_attribute("requested_quantity", quantity)
        
        # Lógica para verificar inventario
        available = get_available_quantity(product_id)
        
        span.set_attribute("available_quantity", available)
        span.set_attribute("is_available", available >= quantity)
        
        return available >= quantity

# Ejemplo: Configuración de health checks en Kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: payment-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: payment-service
  template:
    metadata:
      labels:
        app: payment-service
    spec:
      containers:
      - name: payment-service
        image: mycompany/payment-service:1.2.3
        ports:
        - containerPort: 8080
        livenessProbe:
          httpGet:
            path: /health/live
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /health/ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
          timeoutSeconds: 2
          successThreshold: 1
          failureThreshold: 3
        startupProbe:
          httpGet:
            path: /health/startup
            port: 8080
          failureThreshold: 30
          periodSeconds: 10

// Implementación de endpoints de health en Spring Boot
@RestController
@RequestMapping("/health")
public class HealthController {
    
    private final DatabaseService dbService;
    private final PaymentGatewayClient paymentGateway;
    
    @GetMapping("/live")
    public ResponseEntity<String> liveness() {
        // Verificación básica - ¿está la aplicación respondiendo?
        return ResponseEntity.ok("UP");
    }
    
    @GetMapping("/ready")
    public ResponseEntity<Map<String, String>> readiness() {
        Map<String, String> status = new HashMap<>();
        
        // Verificar dependencias críticas
        boolean dbHealthy = dbService.isConnected();
        boolean gatewayHealthy = paymentGateway.isAvailable();
        
        status.put("database", dbHealthy ? "UP" : "DOWN");
        status.put("paymentGateway", gatewayHealthy ? "UP" : "DOWN");
        
        if (dbHealthy && gatewayHealthy) {
            return ResponseEntity.ok(status);
        } else {
            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(status);
        }
    }
}

# Ejemplo: Configuración de Istio para habilitar monitoreo avanzado
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: payment-service-vs
spec:
  hosts:
  - payment-service
  http:
  - route:
    - destination:
        host: payment-service
        subset: v1
      weight: 90
    - destination:
        host: payment-service
        subset: v2
      weight: 10
    timeout: 0.5s
    retries:
      attempts: 3
      perTryTimeout: 0.2s
    fault:
      delay:
        percentage:
          value: 0.1
        fixedDelay: 0.1s

// Ejemplo: Implementación de Circuit Breaker con Resilience4j
@CircuitBreaker(name = "paymentService", fallbackMethod = "processPaymentFallback")
public PaymentResponse processPayment(PaymentRequest request) {
    return paymentGatewayClient.processPayment(request);
}

public PaymentResponse processPaymentFallback(PaymentRequest request, Exception e) {
    log.error("Payment gateway is down, using fallback", e);
    // Guardar pago para procesamiento posterior o usar un gateway alternativo
    return PaymentResponse.builder()
        .status(PaymentStatus.PENDING)
        .message("Payment queued for later processing")
        .build();
}

# Ejemplo: Rate limiting con Istio
apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  name: filter-ratelimit
  namespace: istio-system
spec:
  configPatches:
    - applyTo: HTTP_FILTER
      match:
        context: SIDECAR_INBOUND
        listener:
          filterChain:
            filter:
              name: "envoy.filters.network.http_connection_manager"
      patch:
        operation: INSERT_BEFORE
        value:
          name: envoy.filters.http.ratelimit
          typed_config:
            "@type": type.googleapis.com/envoy.extensions.filters.http.ratelimit.v3.RateLimit
            domain: payment-service
            rate_limit_service:
              grpc_service:
                envoy_grpc:
                  cluster_name: rate_limit_service

// Ejemplo: Instrumentación de Spring Boot con Micrometer y Prometheus
@Configuration
public class MetricsConfig {
    @Bean
    MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
        return registry -> registry.config().commonTags(
            "application", "payment-service",
            "environment", "${spring.profiles.active}",
            "region", "${app.region}"
        );
    }
    
    @Bean
    TimedAspect timedAspect(MeterRegistry registry) {
        return new TimedAspect(registry);
    }
}

@Service
public class PaymentService {
    private final Counter paymentCounter;
    private final DistributionSummary paymentAmount;
    
    public PaymentService(MeterRegistry registry) {
        this.paymentCounter = registry.counter("payments.total", "type", "credit_card");
        this.paymentAmount = registry.summary("payments.amount", "currency", "USD");
    }
    
    @Timed(value = "payment.processing.time", percentiles = {0.5, 0.95, 0.99})
    public PaymentResult processPayment(Payment payment) {
        // Lógica de procesamiento
        paymentCounter.increment();
        paymentAmount.record(payment.getAmount());
        return result;
    }
}

# docker-compose.yml para stack de monitoreo
version: '3.8'

services:
  prometheus:
    image: prom/prometheus:v2.37.0
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--web.enable-lifecycle'
    ports:
      - "9090:9090"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:9.1.0
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning/:/etc/grafana/provisioning/
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=secure_password
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    depends_on:
      - prometheus
    restart: unless-stopped

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.17.0
    volumes:
      - elasticsearch_data:/usr/share/elasticsearch/data
    environment:
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms512m -Xmx512m
    ports:
      - "9200:9200"
    restart: unless-stopped

  kibana:
    image: docker.elastic.co/kibana/kibana:7.17.0
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    depends_on:
      - elasticsearch
    restart: unless-stopped

  jaeger:
    image: jaegertracing/all-in-one:1.35
    environment:
      - COLLECTOR_ZIPKIN_HOST_PORT=:9411
      - COLLECTOR_OTLP_ENABLED=true
    ports:
      - "5775:5775/udp"
      - "6831:6831/udp"
      - "6832:6832/udp"
      - "5778:5778"
      - "16686:16686"
      - "14268:14268"
      - "14250:14250"
      - "9411:9411"
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:
  elasticsearch_data:

# Ejemplo: Reglas de alerta en Prometheus
groups:
- name: service_alerts
  rules:
  - alert: HighErrorRate
    expr: sum(rate(http_server_requests_seconds_count{status=~"5.."}[5m])) by (service) / sum(rate(http_server_requests_seconds_count[5m])) by (service) > 0.05
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "High error rate on {{ $labels.service }}"
      description: "Service {{ $labels.service }} has error rate above 5% (current value: {{ $value | humanizePercentage }})"

  - alert: SlowResponseTime
    expr: histogram_quantile(0.95, sum(rate(http_server_requests_seconds_bucket[5m])) by (le, service)) > 0.5
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Slow response time on {{ $labels.service }}"
      description: "Service {{ $labels.service }} p95 latency is above 500ms (current value: {{ $value | humanizeDuration }})"

  - alert: HighCPUUsage
    expr: sum(rate(process_cpu_seconds_total{job=~".+"}[3m])) by (service) / count(process_cpu_seconds_total{job=~".+"}) by (service) > 0.7
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High CPU usage on {{ $labels.service }}"
      description: "Service {{ $labels.service }} is using more than 70% CPU (current value: {{ $value | humanizePercentage }})"

  - alert: MemoryLeak
    expr: sum by(service) (jvm_memory_used_bytes{area="heap"}) / sum by(service) (jvm_memory_max_bytes{area="heap"}) > 0.9
    for: 15m
    labels:
      severity: critical
    annotations:
      summary: "Possible memory leak in {{ $labels.service }}"
      description: "Service {{ $labels.service }} is using more than 90% of heap memory for over 15 minutes"

// Ejemplo: Dashboard de Grafana en formato JSON (versión simplificada)
{
  "title": "Microservices Overview",
  "uid": "microservices-overview",
  "panels": [
    {
      "title": "Service Health",
      "type": "stat",
      "targets": [
        {
          "expr": "sum(up{job=~\".*-service\"}) / count(up{job=~\".*-service\"})",
          "format": "time_series"
        }
      ],
      "options": {
        "colorMode": "value",
        "thresholds": {
          "mode": "absolute",
          "steps": [
            { "color": "red", "value": null },
            { "color": "yellow", "value": 0.5 },
            { "color": "green", "value": 0.9 }
          ]
        },
        "textMode": "value"
      },
      "gridPos": {
        "h": 4,
        "w": 4,
        "x": 0,
        "y": 0
      }
    },
    {
      "title": "Request Rate",
      "type": "graph",
      "targets": [
        {
          "expr": "sum(rate(http_server_requests_seconds_count[1m])) by (service)",
          "legendFormat": "{{service}}"
        }
      ],
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 0,
        "y": 4
      }
    },
    {
      "title": "Error Rate",
      "type": "graph",
      "targets": [
        {
          "expr": "sum(rate(http_server_requests_seconds_count{status=~\"5..\"}[1m])) by (service) / sum(rate(http_server_requests_seconds_count[1m])) by (service)",
          "legendFormat": "{{service}}"
        }
      ],
      "options": {
        "legend": { "show": true },
        "tooltip": { "shared": true }
      },
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 12,
        "y": 4
      }
    },
    {
      "title": "Response Time (p95)",
      "type": "graph",
      "targets": [
        {
          "expr": "histogram_quantile(0.95, sum(rate(http_server_requests_seconds_bucket[5m])) by (le, service))",
          "legendFormat": "{{service}}"
        }
      ],
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 0,
        "y": 12
      }
    },
    {
      "title": "Memory Usage",
      "type": "graph",
      "targets": [
        {
          "expr": "sum(jvm_memory_used_bytes{area=\"heap\"}) by (service) / sum(jvm_memory_max_bytes{area=\"heap\"}) by (service)",
          "legendFormat": "{{service}} - Heap"
        },
        {
          "expr": "sum(jvm_memory_used_bytes{area=\"nonheap\"}) by (service) / sum(jvm_memory_max_bytes{area=\"nonheap\"}) by (service)",
          "legendFormat": "{{service}} - Non-Heap"
        }
      ],
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 12,
        "y": 12
      }
    }
  ]
}

// Instrumentación en el reproductor de video
player.on('play', () => {
  const startTime = performance.now();
  
  metrics.timing('video.start_time', startTime - pageLoadTime);
  metrics.increment('video.plays');
});

player.on('buffer', () => {
  bufferStartTime = performance.now();
  metrics.increment('video.buffer_count');
});

player.on('buffer_end', () => {
  if (bufferStartTime) {
    metrics.timing('video.buffer_duration', performance.now() - bufferStartTime);
    bufferStartTime = null;
  }
});

player.on('error', (error) => {
  metrics.increment('video.error', {
    error_type: error.type,
    error_code: error.code
  });
});

// Reporte periódico de métricas de calidad
setInterval(() => {
  metrics.gauge('video.bitrate', player.getCurrentBitrate());
  metrics.gauge('video.framerate', player.getFramerate());
  metrics.gauge('video.buffer_health', player.getBufferLength());
  
  // Correlacionar con métricas de red
  if (navigator.connection) {
    metrics.gauge('network.downlink', navigator.connection.downlink);
    metrics.tag('network.type', navigator.connection.effectiveType);
  }
}, 10000);

{
  "title": "Regulatory Compliance Dashboard",
  "panels": [
    {
      "title": "Service Availability (30-day)",
      "type": "gauge",
      "targets": [
        {
          "expr": "avg_over_time(up[30d]) * 100"
        }
      ],
      "thresholds": [
        { "value": 99.9, "color": "red" },
        { "value": 99.95, "color": "yellow" },
        { "value": 99.99, "color": "green" }
      ]
    },
    {
      "title": "Transaction Response Time (p99)",
      "type": "graph",
      "targets": [
        {
          "expr": "histogram_quantile(0.99, sum(rate(transaction_duration_seconds_bucket[5m])) by (le))"
        }
      ],
      "thresholds": [
        { "value": 3, "line": true, "colorMode": "critical" }
      ]
    },
    {
      "title": "Data Residency Violations",
      "type": "stat",
      "targets": [
        {
          "expr": "sum(increase(data_residency_violations_total[24h]))"
        }
      ]
    },
    {
      "title": "Failed Login Attempts",
      "type": "graph",
      "targets": [
        {
          "expr": "sum(rate(auth_login_failed_total[5m])) by (reason)"
        }
      ]
    }
  ]
}

# Ejemplo: Detección de anomalías con Prophet (Facebook)
from prophet import Prophet
import pandas as pd
import numpy as np

# Cargar datos históricos de latencia
data = pd.read_csv('service_latency.csv')
data = data.rename(columns={'timestamp': 'ds', 'latency_p95': 'y'})

# Entrenar modelo
model = Prophet(
    changepoint_prior_scale=0.05,
    seasonality_mode='multiplicative'
)
model.fit(data)

# Predecir valores futuros
future = model.make_future_dataframe(periods=24, freq='h')
forecast = model.predict(future)

# Detectar anomalías
forecast['actual'] = np.nan
forecast.loc[forecast['ds'].isin(data['ds']), 'actual'] = data['y'].values
forecast['anomaly'] = (
    (forecast['actual'] > forecast['yhat_upper']) | 
    (forecast['actual'] forecast['yhat_lower'])
)

# Generar alertas para anomalías
anomalies = forecast[forecast['anomaly'] == True].tail(24)
if not anomalies.empty:
    print(f"Detected {len(anomalies)} anomalies in the last 24 hours")
    for idx, row in anomalies.iterrows():
        confidence = max(
            abs(row['actual'] - row['yhat_upper']),
            abs(row['actual'] - row['yhat_lower'])
        ) / row['yhat']
        print(f"Anomaly at {row['ds']}: Expected {row['yhat']:.2f}, got {row['actual']:.2f} (confidence: {confidence:.2f})")

# Ejemplo: Observabilidad como código con Terraform
resource "datadog_monitor" "api_latency" {
  name               = "API Latency High"
  type               = "metric alert"
  message            = "API Latency above threshold of 500ms. Notify: @devops-team"
  query              = "avg(last_5m):avg:api.response.time{service:payment-service} > 0.5"
  monitor_thresholds {
    critical = 0.5
    warning  = 0.3
  }
  include_tags       = true
  require_full_window = false
  notify_no_data     = false
  renotify_interval  = 60
  
  tags = ["team:payments", "criticality:high", "service:payment-api"]
}

resource "datadog_service_level_objective" "payment_api_availability" {
  name        = "Payment API Availability"
  type        = "monitor"
  description = "SLO tracking availability of the Payment API"
  monitor_ids = [datadog_monitor.api_availability.id]
  
  thresholds {
    timeframe = "7d"
    target    = 99.95
    warning   = 99.99
  }
  
  thresholds {
    timeframe = "30d"
    target    = 99.9
    warning   = 99.95
  }
  
  tags = ["team:payments", "tier:1", "service:payment-api"]
}

// Ejemplo: Real User Monitoring integrado con tracing de backend
// Código de cliente (frontend)
window.addEventListener('load', () => {
  const traceId = generateTraceId();
  const pageLoadTime = performance.now();
  
  // Capturar métricas de carga de página
  const performanceMetrics = {
    traceId: traceId,
    pageLoad: pageLoadTime,
    domComplete: performance.timing.domComplete - performance.timing.navigationStart,
    firstContentfulPaint: performance.getEntriesByType('paint')
      .find(entry => entry.name === 'first-contentful-paint')?.startTime || 0,
    largestContentfulPaint: getLCP(),
    firstInputDelay: getFID()
  };
  
  // Enviar al backend
  fetch('/api/rum', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Trace-ID': traceId  // Propagación de contexto de tracing
    },
    body: JSON.stringify(performanceMetrics)
  });
  
  // Instrumentar todas las llamadas API subsiguientes
  const originalFetch = window.fetch;
  window.fetch = function(url, options = {}) {
    const fetchStart = performance.now();
    
    // Añadir trace ID a todas las peticiones
    options.headers = options.headers || {};
    options.headers['X-Trace-ID'] = traceId;
    
    return originalFetch.call(this, url, options)
      .then(response => {
        // Capturar métricas de la petición
        const fetchEnd = performance.now();
        const apiMetrics = {
          traceId: traceId,
          url: url,
          duration: fetchEnd - fetchStart,
          status: response.status
        };
        
        // Correlacionar con acciones de usuario
        if (window.currentUserAction) {
          apiMetrics.userAction = window.currentUserAction;
        }
        
        // Enviar métricas al backend
        navigator.sendBeacon('/api/rum/api-call', JSON.stringify(apiMetrics));
        
        return response;
      })
      .catch(error => {
        // Capturar errores
        navigator.sendBeacon('/api/rum/error', JSON.stringify({
          traceId: traceId,
          url: url,
          error: error.message
        }));
        
        throw error;
      });
  };
});

// Rastrear acciones de usuario
document.addEventListener('click', event => {
  if (event.target.closest('button, a, [role="button"]')) {
    const element = event.target.closest('button, a, [role="button"]');
    window.currentUserAction = {
      type: 'click',
      element: element.tagName,
      id: element.id || null,
      text: element.innerText || null,
      timestamp: new Date().toISOString()
    };
  }
});