🎨 Sysprovider Code
Sysprovider LogoWiki
🇪🇸Hosting español para ecommerce

Monitoreo Avanzado de WordPress con OpenTelemetry y Prometheus

Actualizado el 21 de enero de 2026

El ecosistema de WordPress es dinámico, complejo y, a menudo, crítico para el negocio. Un simple plugin mal optimizado o un pico de tráfico inesperado pueden convertir una web rápida en una experiencia frustrante. Las herramientas de monitoreo tradicionales, como los paneles de hosting o los plugins de caché, ofrecen una visibilidad limitada y reactiva.

Para alcanzar un nivel de observabilidad real, necesitas una arquitectura de monitoreo moderna, basada en estándares abiertos. Aquí es donde entran OpenTelemetry y Prometheus. Este artículo te guiará a través de la implementación de un sistema de monitoreo avanzado para WordPress, capaz de detectar cuellos de botella antes de que afecten a tus usuarios.

¿Por qué OpenTelemetry y Prometheus para WordPress?

Antes de sumergirnos en la configuración, entendamos el valor de esta combinación.

  • Prometheus es el estándar de facto para la recolección y alerta de métricas. Es excelente para recopilar datos numéricos (tiempos de respuesta, uso de CPU, consultas a la base de datos) y almacenarlos en una base de datos de series temporales. Su modelo de extracción (pull) es ideal para entornos estables como servidores.
  • OpenTelemetry (OTel) es el framework de observabilidad. No solo recoge métricas, sino también trazos (traces) y logs. En WordPress, un trazo te permite seguir una petición HTTP desde que entra al servidor Nginx, pasa por PHP, ejecuta consultas MySQL, hasta que se renderiza la página. Esto es crucial para identificar dónde se pierde el tiempo.

La sinergia es poderosa: OpenTelemetry genera y exporta los datos, y Prometheus los almacena y te alerta sobre ellos.

[INFO] OpenTelemetry no es un backend de almacenamiento. Es un collector que normaliza y envía datos a backends como Prometheus, Jaeger (para trazas) o Grafana Loki (para logs).

Arquitectura del Sistema de Monitoreo

Para un monitoreo efectivo, necesitamos tres componentes principales:

  1. OpenTelemetry Collector: Un agente ligero que recibe telemetría de WordPress y la procesa.
  2. WordPress Instrumentado: Modificaciones en el código (plugin personalizado o hooks) para exponer métricas.
  3. Prometheus Server: Almacena las métricas y ejecuta reglas de alerta.
  4. Grafana (Opcional pero recomendado): Para visualizar los datos.

Flujo de Datos

  1. Un usuario visita tu web.
  2. PHP ejecuta hooks de WordPress que registran tiempos y contadores.
  3. El OpenTelemetry Collector (corriendo como sidecar o servicio) recibe estos datos a través de un endpoint (por ejemplo, en localhost:4318).
  4. El Collector procesa los datos y los expone en un formato que Prometheus puede "raspar" (scrape).
  5. Prometheus, configurado para raspar al Collector, almacena las métricas.
  6. Grafana consulta Prometheus para mostrar dashboards en tiempo real.

Paso 1: Instalación del OpenTelemetry Collector

El Collector es el cerebro de la operación. Lo instalaremos en el mismo servidor que aloja WordPress. Usaremos Docker para simplificar, pero también puedes instalarlo como binario.

docker-compose.yaml para el Collector:

version: '3.8'
services:
  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    command: ["--config=/etc/otel-collector-config.yaml"]
    volumes:
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
    ports:
      - "4318:4318"   # OTLP HTTP Receiver
      - "8888:8888"   # Prometheus metrics endpoint

Configuración del Collector (otel-collector-config.yaml):

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:
    timeout: 1s
    send_batch_size: 1024

exporters:
  prometheus:
    endpoint: "0.0.0.0:8888"
    namespace: wp_monitor
    const_labels:
      environment: production
      site: midominio.com

service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]

[TIP] El puerto 8888 es donde Prometheus raspará las métricas. El puerto 4318 es donde tu plugin de WordPress enviará los datos vía OTLP.

Paso 2: Instrumentación de WordPress con OpenTelemetry

WordPress no tiene soporte nativo para OpenTelemetry. Necesitamos un plugin personalizado que utilice la librería PHP de OpenTelemetry.

Creación del Plugin Básico

Crea un archivo en wp-content/plugins/wp-observability/wp-observability.php.

<?php
/**
 * Plugin Name: WP Observability
 * Description: Envía métricas de WordPress a OpenTelemetry Collector.
 */

// Requiere la librería de OpenTelemetry (instalada vía Composer)
require_once __DIR__ . '/vendor/autoload.php';

use OpenTelemetry\API\Globals;
use OpenTelemetry\API\Metrics\MeterProviderInterface;
use OpenTelemetry\SDK\Common\Attribute\Attributes;
use OpenTelemetry\SDK\Trace\TracerProvider;
use OpenTelemetry\Contrib\Otlp\OtlpHttpTransportFactory;
use OpenTelemetry\Contrib\Otlp\MetricExporter;
use OpenTelemetry\SDK\Metrics\MeterProvider;
use OpenTelemetry\SDK\Metrics\MetricReader\ExportingReader;

// Configuración del exportador OTLP
$transport = (new OtlpHttpTransportFactory())->create('http://localhost:4318/v1/metrics');
$exporter = new MetricExporter($transport);

// Crear Meter Provider
$meterProvider = MeterProvider::builder()
    ->setResource(ResourceInfoFactory::defaultResource())
    ->addMetricReader(new ExportingReader($exporter))
    ->build();

Globals::setMeterProvider($meterProvider);
$meter = $meterProvider->getMeter('io.opentelemetry.contrib.php.wordpress');

// Definir métricas
$requestDuration = $meter->createHistogram(
    'wp.request.duration',
    'ms',
    'Duración total de la petición HTTP en milisegundos'
);

$queryCount = $meter->createCounter(
    'wp.db.queries.total',
    '1',
    'Número total de consultas a la base de datos por petición'
);

// Hook en 'shutdown' para registrar métricas al final de la petición
add_action('shutdown', function () use ($requestDuration, $queryCount) {
    if (defined('WP_START_TIMESTAMP')) {
        $duration = (microtime(true) - WP_START_TIMESTAMP) * 1000;
        $requestDuration->record($duration, Attributes::create([
            'method' => $_SERVER['REQUEST_METHOD'] ?? 'CLI',
            'endpoint' => $_SERVER['REQUEST_URI'] ?? '/',
        ]));
    }

    global $wpdb;
    if ($wpdb) {
        $queryCount->add($wpdb->num_queries, Attributes::create([
            'type' => 'total',
        ]));
    }
});

// Registrar el timestamp de inicio
add_action('init', function () {
    if (!defined('WP_START_TIMESTAMP')) {
        define('WP_START_TIMESTAMP', microtime(true));
    }
});

[WARNING] Este plugin requiere la librería open-telemetry/opentelemetry-php y open-telemetry/exporter-otlp. Debes instalarla vía Composer dentro de la carpeta del plugin:
cd wp-content/plugins/wp-observability && composer require open-telemetry/opentelemetry-php open-telemetry/exporter-otlp

Métricas Clave a Instrumentar

Además del tiempo de respuesta y consultas, deberías monitorizar:

  • Tiempo de ejecución de hooks: wp.hook.duration (ej: template_redirect, wp_head).
  • Uso de memoria: wp.memory.usage (bytes).
  • Caché: Hits y misses de caché de objeto.
  • Consultas lentas: Una métrica que registre consultas que superen un umbral (ej: 1 segundo).

Paso 3: Configuración de Prometheus

Prometheus necesita saber dónde está el Collector para raspar las métricas.

Configuración de Prometheus (prometheus.yml):

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'wordpress-otel-collector'
    scrape_interval: 10s
    static_configs:
      - targets: ['localhost:8888']  # IP del Collector
        labels:
          app: 'wordpress'
          tier: 'backend'

  - job_name: 'node_exporter'  # Para métricas del servidor (CPU, RAM, disco)
    static_configs:
      - targets: ['localhost:9100']

Ahora, Prometheus raspará métricas como wp_request_duration_count, wp_request_duration_sum, wp_db_queries_total. Con estas métricas puedes calcular promedios, percentiles (P95, P99) y tasas por segundo.

Paso 4: Alertas Inteligentes con Prometheus

El verdadero poder del monitoreo avanzado está en las alertas proactivas. Configura reglas para detectar problemas antes de que se conviertan en caídas.

Reglas de Alerta (alerts.yml):

groups:
  - name: wordpress_alerts
    rules:
      - alert: HighRequestLatency
        expr: |
          (
            rate(wp_request_duration_sum[5m])
            /
            rate(wp_request_duration_count[5m])
          ) > 2000
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Latencia alta en WordPress ({{ $value }} ms)"
          description: "El tiempo de respuesta promedio supera los 2000 ms en los últimos 5 minutos."

      - alert: DatabaseQuerySpike
        expr: |
          rate(wp_db_queries_total[1m]) > 500
        for: 1m
        labels:
          severity: warning
        annotations:
          summary: "Pico de consultas a la base de datos"
          description: "Se están ejecutando más de 500 consultas por segundo."

      - alert: MemoryLeak
        expr: |
          wp_memory_usage > 200000000  # 200 MB
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Uso de memoria excesivo"
          description: "WordPress está usando más de 200 MB de RAM."

[TIP] Usa rate() para calcular la velocidad de las métricas contadores (como consultas DB) y evita falsos positivos con for: para que la condición se mantenga durante un tiempo.

Paso 5: Visualización en Grafana

Grafana es el aliado perfecto para Prometheus. Crea un dashboard que muestre:

  • Latencia de peticiones: Percentil 95 y 99.
  • Consultas a la base de datos: Por segundo y por tipo (SELECT, INSERT).
  • Uso de recursos del servidor: CPU, RAM, disco (vía Node Exporter).
  • Tasa de errores HTTP: Códigos 4xx y 5xx.

Una consulta típica en Grafana para ver el tiempo de respuesta promedio sería:

rate(wp_request_duration_sum[5m]) / rate(wp_request_duration_count[5m])

Consideraciones de Rendimiento y Seguridad

Instrumentar WordPress añade una sobrecarga mínima, pero debes tener cuidado:

  • Usa el modo batch en el Collector para agrupar envíos.
  • No instrumentes el panel de administración (wp-admin) a menos que sea necesario. Puedes filtrar por is_admin() en el plugin.
  • Protege el endpoint del Collector: No lo expongas a internet. Debe escuchar solo en localhost o en una red privada.
  • Límites de memoria: Si tu sitio tiene mucho tráfico, considera usar un buffer en memoria antes de enviar las métricas para no bloquear la respuesta de PHP.

Conclusión

El monitoreo avanzado de WordPress con OpenTelemetry y Prometheus transforma la gestión de tu sitio. Pasas de un enfoque reactivo ("el sitio está lento") a uno proactivo ("la latencia P99 está aumentando debido a un plugin de WooCommerce").

Con esta configuración, no solo mides métricas superficiales, sino que obtienes visibilidad de extremo a extremo de cada petición. Puedes correlacionar un pico de consultas SQL con una campaña de marketing o identificar un plugin que filtra memoria.

Implementa este stack hoy y eleva la fiabilidad de tu WordPress al siguiente nivel. La inversión en tiempo de configuración se paga con creces la primera vez que una alerta te avisa de un problema antes de que tus usuarios lo noten.

¿Necesitas ayuda?Son dos de nuestros técnicos, Agustín y Mikel, y están disponibles para resolver cualquier problema.

Hablar con ellos ahora
Agustín y Mikel