308 lines
10 KiB
YAML
308 lines
10 KiB
YAML
metrics:
|
|
##
|
|
# Discovery metrics
|
|
##
|
|
discover_dbs:
|
|
type: set
|
|
query:
|
|
0: >
|
|
SELECT datname AS dbname
|
|
FROM pg_database
|
|
|
|
# Note: If the user lacks sufficient privileges, these fields will be NULL.
|
|
# The WHERE clause is intended to prevent Zabbix from discovering a
|
|
# connection it cannot monitor. Ideally this would generate an error
|
|
# instead.
|
|
discover_rep:
|
|
type: set
|
|
query:
|
|
0: >
|
|
SELECT host(client_addr) || '_' || regexp_replace(application_name, '[ ,]', '_', 'g') AS repid,
|
|
client_addr,
|
|
state
|
|
FROM pg_stat_replication
|
|
WHERE state IS NOT NULL
|
|
|
|
discover_slots:
|
|
type: set
|
|
query:
|
|
90400: >
|
|
SELECT slot_name,
|
|
plugin,
|
|
slot_type,
|
|
database,
|
|
false as temporary,
|
|
active
|
|
FROM pg_replication_slots
|
|
100000: >
|
|
SELECT slot_name,
|
|
plugin,
|
|
slot_type,
|
|
database,
|
|
temporary,
|
|
active
|
|
FROM pg_replication_slots
|
|
|
|
|
|
##
|
|
# cluster-wide metrics
|
|
##
|
|
version:
|
|
type: value
|
|
query:
|
|
0: SHOW server_version_num
|
|
|
|
max_frozen_age:
|
|
type: row
|
|
query:
|
|
0: >
|
|
SELECT max(age(datfrozenxid)) AS xid_age,
|
|
NULL AS mxid_age
|
|
FROM pg_database
|
|
90600: >
|
|
SELECT max(age(datfrozenxid)) AS xid_age,
|
|
max(mxid_age(datminmxid)) AS mxid_age
|
|
FROM pg_database
|
|
|
|
bgwriter:
|
|
type: row
|
|
query:
|
|
0: >
|
|
SELECT checkpoints_timed,
|
|
checkpoints_req,
|
|
checkpoint_write_time,
|
|
checkpoint_sync_time,
|
|
buffers_checkpoint,
|
|
buffers_clean,
|
|
maxwritten_clean,
|
|
buffers_backend,
|
|
buffers_backend_fsync,
|
|
buffers_alloc
|
|
FROM pg_stat_bgwriter
|
|
170000: >
|
|
SELECT cp.num_timed AS checkpoints_timed,
|
|
cp.num_requested AS checkpoints_req,
|
|
cp.write_time AS checkpoint_write_time,
|
|
cp.sync_time AS checkpoint_sync_time,
|
|
cp.buffers_written AS buffers_checkpoint,
|
|
bg.buffers_clean AS buffers_clean,
|
|
bg.maxwritten_clean AS maxwritten_clean,
|
|
NULL AS buffers_backend,
|
|
NULL AS buffers_backend_fsync,
|
|
bg.buffers_alloc AS buffers_alloc
|
|
FROM pg_stat_bgwriter bg
|
|
CROSS JOIN pg_stat_checkpointer cp
|
|
|
|
io_per_backend:
|
|
type: set
|
|
query:
|
|
160000: >
|
|
SELECT backend_type,
|
|
COALESCE(SUM(reads * op_bytes), 0)::bigint AS reads,
|
|
COALESCE(SUM(read_time), 0)::bigint AS read_time,
|
|
COALESCE(SUM(writes * op_bytes), 0)::bigint AS writes,
|
|
COALESCE(SUM(write_time), 0)::bigint AS write_time,
|
|
COALESCE(SUM(writebacks * op_bytes), 0)::bigint AS writebacks,
|
|
COALESCE(SUM(writeback_time), 0)::bigint AS writeback_time,
|
|
COALESCE(SUM(extends * op_bytes), 0)::bigint AS extends,
|
|
COALESCE(SUM(extend_time), 0)::bigint AS extend_time,
|
|
COALESCE(SUM(op_bytes), 0)::bigint AS op_bytes,
|
|
COALESCE(SUM(hits), 0)::bigint AS hits,
|
|
COALESCE(SUM(evictions), 0)::bigint AS evictions,
|
|
COALESCE(SUM(reuses), 0)::bigint AS reuses,
|
|
COALESCE(SUM(fsyncs), 0)::bigint AS fsyncs,
|
|
COALESCE(SUM(fsync_time), 0)::bigint AS fsync_time
|
|
FROM pg_stat_io
|
|
GROUP BY backend_type
|
|
|
|
|
|
##
|
|
# Per-database metrics
|
|
##
|
|
db_stats:
|
|
type: row
|
|
query:
|
|
0: >
|
|
SELECT numbackends,
|
|
xact_commit,
|
|
xact_rollback,
|
|
blks_read,
|
|
blks_hit,
|
|
tup_returned,
|
|
tup_fetched,
|
|
tup_inserted,
|
|
tup_updated,
|
|
tup_deleted,
|
|
conflicts,
|
|
temp_files,
|
|
temp_bytes,
|
|
deadlocks,
|
|
NULL AS checksum_failures,
|
|
blk_read_time,
|
|
blk_write_time,
|
|
NULL AS session_time,
|
|
NULL AS active_time,
|
|
NULL AS idle_in_transaction_time,
|
|
NULL AS sessions,
|
|
NULL AS sessions_abandoned,
|
|
NULL AS sessions_fatal,
|
|
NULL AS sessions_killed,
|
|
extract('epoch' from stats_reset)::float AS stats_reset
|
|
FROM pg_stat_database WHERE datname = %(dbname)s
|
|
140000: >
|
|
SELECT numbackends,
|
|
xact_commit,
|
|
xact_rollback,
|
|
blks_read,
|
|
blks_hit,
|
|
tup_returned,
|
|
tup_fetched,
|
|
tup_inserted,
|
|
tup_updated,
|
|
tup_deleted,
|
|
conflicts,
|
|
temp_files,
|
|
temp_bytes,
|
|
deadlocks,
|
|
COALESCE(checksum_failures, 0) AS checksum_failures,
|
|
blk_read_time,
|
|
blk_write_time,
|
|
session_time,
|
|
active_time,
|
|
idle_in_transaction_time,
|
|
sessions,
|
|
sessions_abandoned,
|
|
sessions_fatal,
|
|
sessions_killed,
|
|
extract('epoch' from stats_reset)::float AS stats_reset
|
|
FROM pg_stat_database WHERE datname = %(dbname)s
|
|
test_args:
|
|
dbname: postgres
|
|
|
|
hit_ratios:
|
|
type: row
|
|
query:
|
|
0: >
|
|
SELECT sum(heap_blks_read)::float / NULLIF(sum(heap_blks_read + heap_blks_hit), 0) AS avg_heap_hit_ratio,
|
|
sum(idx_blks_hit)::float / NULLIF(sum(idx_blks_read + idx_blks_hit), 0) AS avg_idx_hit_ratio,
|
|
sum(toast_blks_hit)::float / NULLIF(sum(toast_blks_read + toast_blks_hit), 0) AS avg_toast_hit_ratio,
|
|
sum(tidx_blks_hit)::float / NULLIF(sum(tidx_blks_read + tidx_blks_hit), 0) AS avg_tidx_hit_ratio
|
|
FROM pg_statio_all_tables
|
|
test_args:
|
|
dbname: postgres
|
|
|
|
activity:
|
|
type: set
|
|
query:
|
|
0: >
|
|
SELECT state,
|
|
count(*) AS backend_count,
|
|
COALESCE(EXTRACT(EPOCH FROM max(now() - state_change))::float, 0) AS max_state_time
|
|
FROM pg_stat_activity
|
|
WHERE datname = %(dbname)s
|
|
GROUP BY state
|
|
test_args:
|
|
dbname: postgres
|
|
|
|
sequence_usage:
|
|
type: value
|
|
query:
|
|
# 9.2 lacks lateral joins, the pg_sequence_last_value function, and the pg_sequences view
|
|
# 0: >
|
|
# SELECT COALESCE(MAX(pg_sequence_last_value(c.oid)::float / (pg_sequence_parameters(oid)).maximum_value), 0) AS max_usage
|
|
# FROM pg_class c
|
|
# WHERE c.relkind = 'S'
|
|
# 9.3 - 9.6 lacks the pg_sequence_last_value function, and pg_sequences view
|
|
# 90300: >
|
|
# SELECT COALESCE(MAX(pg_sequence_last_value(c.oid)::float / s.maximum_value), 0) AS max_usage
|
|
# FROM pg_class c
|
|
# CROSS JOIN LATERAL pg_sequence_parameters(c.oid) AS s
|
|
# WHERE c.relkind = 'S'
|
|
100000: SELECT COALESCE(MAX(last_value::float / max_value), 0) AS max_usage FROM pg_sequences;
|
|
test_args:
|
|
dbname: postgres
|
|
|
|
sequence_visibility:
|
|
type: row
|
|
query:
|
|
100000: >
|
|
SELECT COUNT(*) FILTER (WHERE has_sequence_privilege(c.oid, 'SELECT,USAGE'::text)) AS readable_sequences,
|
|
COUNT(*) AS total_sequences
|
|
FROM pg_class AS c
|
|
WHERE relkind = 'S';
|
|
|
|
|
|
##
|
|
# Per-replication metrics
|
|
##
|
|
rep_stats:
|
|
type: row
|
|
query:
|
|
90400: >
|
|
SELECT pid, usename,
|
|
EXTRACT(EPOCH FROM backend_start)::integer AS backend_start,
|
|
state,
|
|
pg_xlog_location_diff(pg_current_xlog_location(), sent_location) AS sent_lsn,
|
|
pg_xlog_location_diff(pg_current_xlog_location(), write_location) AS write_lsn,
|
|
pg_xlog_location_diff(pg_current_xlog_location(), flush_location) AS flush_lsn,
|
|
pg_xlog_location_diff(pg_current_xlog_location(), replay_location) AS replay_lsn,
|
|
NULL AS write_lag,
|
|
NULL AS flush_lag,
|
|
NULL AS replay_lag,
|
|
sync_state
|
|
FROM pg_stat_replication
|
|
WHERE host(client_addr) || '_' || regexp_replace(application_name, '[ ,]', '_', 'g') = %(repid)s
|
|
100000: >
|
|
SELECT pid, usename,
|
|
EXTRACT(EPOCH FROM backend_start)::integer AS backend_start,
|
|
state,
|
|
pg_wal_lsn_diff(pg_current_wal_lsn(), sent_lsn) AS sent_lsn,
|
|
pg_wal_lsn_diff(pg_current_wal_lsn(), write_lsn) AS write_lsn,
|
|
pg_wal_lsn_diff(pg_current_wal_lsn(), flush_lsn) AS flush_lsn,
|
|
pg_wal_lsn_diff(pg_current_wal_lsn(), replay_lsn) AS replay_lsn,
|
|
COALESCE(EXTRACT(EPOCH FROM write_lag), 0)::integer AS write_lag,
|
|
COALESCE(EXTRACT(EPOCH FROM flush_lag), 0)::integer AS flush_lag,
|
|
COALESCE(EXTRACT(EPOCH FROM replay_lag), 0)::integer AS replay_lag,
|
|
sync_state
|
|
FROM pg_stat_replication
|
|
WHERE host(client_addr) || '_' || regexp_replace(application_name, '[ ,]', '_', 'g') = %(repid)s
|
|
test_args:
|
|
repid: 127.0.0.1_test_rep
|
|
|
|
|
|
##
|
|
# Per-slot metrics
|
|
##
|
|
slot_stats:
|
|
type: row
|
|
query:
|
|
90400: >
|
|
SELECT NULL as active_pid,
|
|
xmin,
|
|
pg_xlog_location_diff(pg_current_xlog_location(), restart_lsn)::bigint AS restart_bytes,
|
|
NULL AS confirmed_flush_bytes
|
|
FROM pg_replication_slots WHERE slot_name = %(slot)s
|
|
90600: >
|
|
SELECT active_pid,
|
|
xmin,
|
|
pg_xlog_location_diff(pg_current_xlog_location(), restart_lsn)::bigint AS restart_bytes,
|
|
pg_xlog_location_diff(pg_current_xlog_location(), confirmed_flush_lsn)::bigint AS confirmed_flush_bytes
|
|
FROM pg_replication_slots WHERE slot_name = %(slot)s
|
|
100000: >
|
|
SELECT active_pid,
|
|
xmin,
|
|
pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn)::bigint AS restart_bytes,
|
|
pg_wal_lsn_diff(pg_current_wal_lsn(), confirmed_flush_lsn)::bigint AS confirmed_flush_bytes
|
|
FROM pg_replication_slots WHERE slot_name = %(slot)s
|
|
test_args:
|
|
slot: test_slot
|
|
|
|
|
|
##
|
|
# Debugging
|
|
##
|
|
ntables:
|
|
type: value
|
|
query:
|
|
0: SELECT count(*) AS ntables FROM pg_stat_user_tables
|