Supervisa el rendimiento de la base de datos de AlloyDB Omni

Selecciona una versión de la documentación:

En esta página, se describe cómo supervisar el rendimiento de tu base de datos de AlloyDB Omni con secuencias de comandos de observabilidad de PostgreSQL.

Visualiza el estado de los procesos conectados y los eventos de espera

Puedes determinar cualquier proceso conectado a tu instancia de AlloyDB Omni, así como cualquier backend que esté esperando actividad, consultando la vista pg_stat_activity.

SELECT
    pid,
    datname,
    age(backend_xid) AS age_in_xids,
    now() - xact_start AS xact_age,
    now() - query_start AS query_age,
    state,
    wait_event_type,
    wait_event,
    query_id,
    query
FROM
    pg_stat_activity
WHERE
    state != 'idle'
    AND pid <> pg_backend_pid()
ORDER BY
    4 DESC
LIMIT 10;

Ver las tablas más grandes

Para determinar el tamaño de tus tablas más grandes, consulta la vista pg_stat_user_tables.

SELECT
    oid,
    oid::regclass table_name,
    pg_size_pretty(pg_relation_size(oid)),
    relpages,
    s.seq_scan,
    s.idx_scan
FROM
    pg_class,
    pg_stat_user_tables s
WHERE
    s.relid = oid
    AND oid > 16383
    AND relpages > 100
    AND relkind = 'r'
ORDER BY
    relpages DESC
LIMIT 20;

Visualiza los análisis secuenciales principales

Para ver las principales exploraciones secuenciales, consulta la vista pg_stat_user_tables.

SELECT
    relid,
    relname,
    seq_scan,
    pg_size_pretty(pg_relation_size(relid))
FROM
    pg_stat_user_tables
ORDER BY
    seq_scan DESC
LIMIT 15;

Visualiza los análisis de índices principales

Para ver los análisis de índices principales, consulta la vista pg_stat_user_tables.

SELECT
    relid,
    relid::regclass table_name,
    idx_scan,
    pg_size_pretty(pg_relation_size(relid))
FROM
    pg_stat_user_tables
WHERE
    idx_scan > 10
ORDER BY
    idx_scan DESC
LIMIT 15;

Visualiza las transacciones más largas en ejecución

Para ver las transacciones de mayor duración, consulta la vista pg_stat_activity y verifica la antigüedad de la transacción.

SELECT
    pid,
    age(backend_xid) AS age_in_xids,
    now() - xact_start AS xact_age,
    now() - query_start AS query_age,
    state,
    query
FROM
    pg_stat_activity
WHERE
    state != 'idle'
ORDER BY
    2 DESC
LIMIT 10;

Verifica el progreso de la aspiradora

Puedes verificar el progreso de las operaciones de limpieza consultando la vista pg_stat_progress_vacuum y uniéndola con la vista pg_stat_activity con los IDs de proceso.

SELECT
  p.pid,
  now() - a.xact_start AS duration,
  coalesce(wait_event_type ||'.'|| wait_event, 'f') AS waiting,
  CASE
    WHEN a.query ~*'^autovacuum.*to prevent wraparound' THEN 'wraparound'
    WHEN a.query ~*'^vacuum' THEN 'user'
  ELSE
    'regular'
  END AS mode,
  p.datname AS database,
  p.relid::regclass AS table,
  p.phase,
  pg_size_pretty(p.heap_blks_total * current_setting('block_size')::int) AS table_size,
  pg_size_pretty(pg_total_relation_size(relid)) AS total_size,
  pg_size_pretty(p.heap_blks_scanned * current_setting('block_size')::int) AS scanned,
  pg_size_pretty(p.heap_blks_vacuumed * current_setting('block_size')::int) AS vacuumed,
  round(100.0 * p.heap_blks_scanned / p.heap_blks_total, 1) AS scanned_pct,
  round(100.0 * p.heap_blks_vacuumed / p.heap_blks_total, 1) AS vacuumed_pct,
  p.index_vacuum_count,
  round(100.0 * p.dead_tuple_bytes / p.max_dead_tuple_bytes,1) AS dead_pct
FROM pg_stat_progress_vacuum p
JOIN pg_stat_activity a using (pid)
ORDER BY now() - a.xact_start DESC;

Visualiza consultas asíncronas

Para ver las consultas que se ejecutan de forma asíncrona, puedes consultar la vista pg_stat_activity y filtrar las consultas que no son el proceso líder.

SELECT
    query,
    leader_pid,
    array_agg(pid) FILTER (WHERE leader_pid != pid) AS members
FROM
    pg_stat_activity
WHERE
    leader_pid IS NOT NULL
GROUP BY
    query,
    leader_pid;

Ver SQL de bloqueo

Para ver la actividad que está bloqueada, consulta la vista pg_locks y únelas con la vista pg_stat_activity.

SELECT blocked_locks.pid     AS blocked_pid,
       blocked_activity.usename  AS blocked_user,
       blocking_locks.pid     AS blocking_pid,
       blocking_activity.usename AS blocking_user,
       blocked_activity.query    AS blocked_statement,
       blocked_activity.wait_event AS blocked_wait_event,
       blocking_activity.wait_event AS blocking_wait_event,
       blocking_activity.query   AS current_statement_in_blocking_process
 FROM  pg_catalog.pg_locks         blocked_locks
  JOIN pg_catalog.pg_stat_activity blocked_activity  ON blocked_activity.pid = blocked_locks.pid
  JOIN pg_catalog.pg_locks         blocking_locks
      ON blocking_locks.locktype = blocked_locks.locktype
      AND blocking_locks.database IS NOT DISTINCT FROM blocked_locks.database
      AND blocking_locks.relation IS NOT DISTINCT FROM blocked_locks.relation
      AND blocking_locks.page IS NOT DISTINCT FROM blocked_locks.page
      AND blocking_locks.tuple IS NOT DISTINCT FROM blocked_locks.tuple
      AND blocking_locks.virtualxid IS NOT DISTINCT FROM blocked_locks.virtualxid
      AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid
      AND blocking_locks.classid IS NOT DISTINCT FROM blocked_locks.classid
      AND blocking_locks.objid IS NOT DISTINCT FROM blocked_locks.objid
      AND blocking_locks.objsubid IS NOT DISTINCT FROM blocked_locks.objsubid
      AND blocking_locks.pid != blocked_locks.pid
  JOIN pg_catalog.pg_stat_activity blocking_activity ON blocking_activity.pid = blocking_locks.pid
 WHERE NOT blocked_locks.granted;

Determina la eficacia del tamaño de work_mem y temp_buffers

Para determinar si tus work_mem y temp_buffers tienen el tamaño correcto para tus necesidades, puedes consultar la vista pg_stat_database y verificar el archivo postgres.log. Con pg_stat_database, ejecuta la siguiente consulta y, si hay algún crecimiento en temp_files o temp_bytes entre las ejecuciones, es probable que sea necesario ajustar work_mem o temp_buffers.

SELECT
    datname,
    temp_files,
    temp_bytes
FROM
    pg_stat_database;

Después de ejecutar esto, verifica el archivo postgres.log para ver si se usaron archivos temporales:

LOG: [fd.c:1772] temporary file: path "base/pgsql_tmp/pgsql_tmp4640.1", size 139264

El objetivo es minimizar la creación de archivos temporales, no evitar por completo que se produzcan. Esto se debe a que configurar work_mem y temp_buffers es un equilibrio entre la memoria disponible en el host y la cantidad de conexiones que requieren la memoria. Para configurar estos parámetros de forma correcta, se debe comprender cada carga de trabajo individual.

Visualiza el rendimiento de las consultas con Estadísticas de consultas

Puedes identificar consultas lentas y sentencias de E/S de disco altas con las Estadísticas de consultas en la interfaz de usuario web de AlloyDB Omni. Estadísticas de consultas requiere que la extensión pg_stat_statements esté habilitada en tu base de datos. Para obtener instrucciones de configuración, consulta Instala la IU web.

Para ver las métricas de rendimiento de las consultas en la IU web, completa los siguientes pasos:

  1. Conéctate a la IU web y selecciona tu clúster.
  2. En el menú de navegación, haz clic en Estadísticas de consultas.
  3. Opcional: Usa la lista Base de datos para filtrar las sentencias por una base de datos específica o selecciona Todas las bases de datos.
  4. Revisa la tabla Consultas para analizar las estadísticas de ejecución de SQL. En cada fila, se muestran las siguientes métricas junto con la instrucción de SQL completa debajo de la fila:
    • Nombre de la base de datos: Es la base de datos lógica en la que se ejecutó la sentencia.
    • Llamadas: Es la cantidad total de veces que se ejecutó la sentencia.
    • Filas: Es la cantidad total de filas recuperadas o afectadas por la sentencia.
    • Tiempo de ejecución: promedio: Es el tiempo de ejecución promedio por llamada.
    • Tiempo de ejecución: total: Es el tiempo de ejecución acumulado en todas las llamadas.
    • Acierto de bloque compartido: Es la cantidad total de aciertos de caché de búfer compartido.
    • Lectura de bloques compartidos: Es la cantidad total de bloques compartidos que se leyeron del disco.
    • Tipo de consulta: Clasifica el impacto en el rendimiento de la consulta, como Slow query o High disk IO.