Una escena que muchos ingenieros conocemos demasiado bien: la monitorización del backend detecta un repunte molesto en la latencia de la base de datos en los percentiles p95 y p99, la cola de peticiones HTTP empieza a crecer de forma preocupante y, sin embargo, la gráfica de CPU del servidor de base de datos marca un tranquilo 15-20 %. La primera reacción impulsiva de dirección suele ser un escalado vertical a ciegas («pasemos la base de datos a una instancia de 64 núcleos en vez de 16»). Pero tras reiniciar y pagar una factura cloud astronómica, nada cambia: las latencias siguen exactamente igual.
La razón es sencilla: en la inmensa mayoría de los casos, el cuello de botella de un SGBD no está en la falta de potencia de cálculo, sino en atascos arquitectónicos: bloqueos invisibles entre transacciones, planes de escaneo subóptimos y fallos contra la caché de búferes.
En la guía de la comunidad SQL Portal («Búsqueda de cuellos de botella en la base de datos») se sistematiza un algoritmo claro de diagnóstico para PostgreSQL que permite aislar el problema en cuestión de minutos sin detener producción.
Separar el tiempo: cómputo frente a esperas
El primer paso de una investigación seria es dividir la latencia total en dos componentes independientes: el tiempo neto de ejecución en CPU (execution time) y el tiempo de espera forzosa en cola (wait time).
Para eso consultamos la vista del sistema pg_stat_activity. Si una consulta se queda colgada durante segundos pero la CPU está ociosa, casi con toda seguridad está esperando a que se libere un recurso. La columna wait_event_type apunta directamente al motivo:
Lock: la sesión espera a que otra transacción libere un bloqueo de fila o de tabla;IO: la consulta ha topado con la velocidad del disco (lectura de páginas de datos o espera de volcado del WAL);Client: el servidor espera instrucciones desde la aplicación cliente (el clásico estadoidle in transaction).
Aquí tienes una consulta SQL probada que destapa al instante el árbol de bloqueos y localiza la sesión culpable:
SELECT
blocked.pid AS blocked_pid,
blocked.usename AS blocked_user,
blocking.pid AS blocking_pid,
blocking.usename AS blocking_user,
blocked.wait_event_type,
blocked.wait_event,
left(blocked.query, 60) AS blocked_query,
left(blocking.query, 60) AS blocking_query
FROM pg_stat_activity AS blocked
JOIN pg_stat_activity AS blocking
ON blocking.pid = ANY(pg_blocking_pids(blocked.pid))
WHERE NOT blocked.pid = pg_backend_pid();
La función pg_blocking_pids cruza cada sesión bloqueada con los PIDs que la retienen y te muestra cara a cara tanto la consulta atascada como la que está sosteniendo el candado.
Si ves una sesión en estado idle in transaction reteniendo un bloqueo exclusivo, puedes cerrarla de forma selectiva con SELECT pg_terminate_backend(blocking_pid); y devolver la vida al clúster al instante.
Cazar a los culpables con pg_stat_statements
Cuando no hay bloqueos pero la base sufre por lecturas lentas, entra en juego la extensión pg_stat_statements. Normaliza las consultas SQL (sustituyendo IDs concretos por marcadores) y acumula estadísticas detalladas de todo el clúster.
En nuestro estudio práctico sobre cómo buscar consultas pesadas con pg_stat_statements cuando la CPU está libre, ya analizamos las métricas de búferes. En el 80 % de los casos, la degradación de la base viene provocada por apenas dos o tres consultas que lanzan escaneos secuenciales (Seq Scan) sobre tablas de millones de filas y barren los shared_buffers.
La siguiente query aísla el top de consultas por tiempo acumulado evaluando la eficacia de su caché:
SELECT
queryid,
calls,
round(total_exec_time::numeric, 2) AS total_ms,
round(mean_exec_time::numeric, 2) AS mean_ms,
round((shared_blks_hit::numeric / nullif(shared_blks_hit + shared_blks_read, 0) * 100)::numeric, 1) AS hit_percent,
left(query, 80) AS query_preview
FROM pg_stat_statements
ORDER BY total_exec_time DESC
LIMIT 5;
Al ordenar por total_exec_time y calcular hit_percent a partir de bloques servidos desde memoria frente a bloques leídos de disco, ves de un vistazo qué cinco consultas queman más tiempo global y cuáles están tirando de almacenamiento.
Si el porcentaje de acierto en caché (hit_percent) cae por debajo del 95 %, esa consulta está obligando al kernel a leer datos directamente desde disco.
En el artículo sobre cómo diagnosticar cargas de alta cardinalidad en pg_stat_statements, vimos también la importancia de parametrizar bien las consultas para no desbordar el búfer de la propia extensión.
No ejecutes nunca EXPLAIN ANALYZE sobre consultas pesadas de modificación de datos (UPDATE/DELETE) en producción sin envolverlas en una transacción con rollback (BEGIN ... ROLLBACK). Para analizar sin riesgo usa EXPLAIN (BUFFERS, COSTS), que muestra las páginas de disco estimadas sin alterar ni una fila.
Antes de escalar servidores a ciegas, dedica 15 minutos a hacer una radiografía de bloqueos y estadísticas de búferes: tu base de datos volverá a ir como un reloj suizo.

