Skip to content

Metrics

Current PGSQL recording rules, raw metric sources, and historical scrape samples.

This page separates raw metrics from scrape endpoints from recorded metrics computed by vmalert. files/victoria/rules/pgsql.yml defines 402 recording rules. Common examples appear below; the Recording Metric Index lists every name and expression. Query recorded metrics in VictoriaMetrics, not at an exporter’s /metrics endpoint.

Raw metrics vary with software versions, collectors, privileges, instance roles, and runtime state. Historical scrape samples are retained for identifying metrics, not as a complete interface for the current version.

Raw PostgreSQL and PgBouncer metrics are defined in pg_exporter.yml and pgbouncer_exporter.yml, respectively. Patroni, pgBackRest Exporter, and exporter runtime metrics come from their own implementations. SQL collectors are selected by min_version / max_version, role tags, and probe queries; they do not all run on the same instance.

Current Recording Rules

ins, cls, and env refer to instance, cluster, and environment levels; actual aggregation labels depend on each expression. See Metric Definitions and Counts for differences in types and counts between recorded and raw metrics.

Recorded MetricExpressionMeaning or Unit
pg:ins:statuspg_up * 2 + (1 - pg_in_recovery)Instance status code combining availability and primary/replica role
pg:ins:cpu_usagenode:ins:cpu_usage_1m + on(ip) group_right() pg_up * 0CPU utilization fraction on the host node
pg:cls:lag_bytesmax by (job, cls) (pg:ins:lag_bytes)Maximum replication lag in the cluster, bytes
pg:cls:lag_secondsmax by (job, cls) (pg:ins:lag_seconds)Maximum replication lag in the cluster, seconds
pg:db:xact_total_rate1mrate(pg_db_xact_total[1m])Database transactions per second
pg:cls:xact_total_rate1msum by (job, cls) (pg:ins:xact_total_rate1m)Cluster transactions per second
pgbouncer:ins:query_rate1msum without(datname) (pgbouncer:db:query_rate1m)Connection-pool queries per second
pgbouncer:ins:query_rt_1mpgbouncer:ins:query_time_rate1m / pgbouncer:ins:query_rate1mRatio of the cumulative query-time rate to the query rate

In addition, pg_exporter_agent_up, pgbouncer_exporter_agent_up, pgbackrest_exporter_agent_up, patroni_up come from Infra’s shared liveness recording rules. They are excluded from the module rule count above and are not raw exporter metrics. They reflect scrape status and do not replace functional service checks.

Historical Scrape Sample

The existing sample below retains 405 metric names, with recording-rule and alert-state series removed. Its scrape time and software versions were not recorded, so types and labels are for reference only. Unknown indicates missing type metadata. See Metric Definitions and Counts for the counting method.

Metric NameTypeLabelsDescription
go_gc_duration_secondssummaryjob, ins, ip, instance, quantile, clsA summary of the pause duration of garbage collection cycles.
go_gc_duration_seconds_countUnknownjob, ins, ip, instance, clsN/A
go_gc_duration_seconds_sumUnknownjob, ins, ip, instance, clsN/A
go_goroutinesgaugejob, ins, ip, instance, clsNumber of goroutines that currently exist.
go_infogaugeversion, job, ins, ip, instance, clsInformation about the Go environment.
go_memstats_alloc_bytesgaugejob, ins, ip, instance, clsNumber of bytes allocated and still in use.
go_memstats_alloc_bytes_totalcounterjob, ins, ip, instance, clsTotal number of bytes allocated, even if freed.
go_memstats_buck_hash_sys_bytesgaugejob, ins, ip, instance, clsNumber of bytes used by the profiling bucket hash table.
go_memstats_frees_totalcounterjob, ins, ip, instance, clsTotal number of frees.
go_memstats_gc_sys_bytesgaugejob, ins, ip, instance, clsNumber of bytes used for garbage collection system metadata.
go_memstats_heap_alloc_bytesgaugejob, ins, ip, instance, clsNumber of heap bytes allocated and still in use.
go_memstats_heap_idle_bytesgaugejob, ins, ip, instance, clsNumber of heap bytes waiting to be used.
go_memstats_heap_inuse_bytesgaugejob, ins, ip, instance, clsNumber of heap bytes that are in use.
go_memstats_heap_objectsgaugejob, ins, ip, instance, clsNumber of allocated objects.
go_memstats_heap_released_bytesgaugejob, ins, ip, instance, clsNumber of heap bytes released to OS.
go_memstats_heap_sys_bytesgaugejob, ins, ip, instance, clsNumber of heap bytes obtained from system.
go_memstats_last_gc_time_secondsgaugejob, ins, ip, instance, clsNumber of seconds since 1970 of last garbage collection.
go_memstats_lookups_totalcounterjob, ins, ip, instance, clsTotal number of pointer lookups.
go_memstats_mallocs_totalcounterjob, ins, ip, instance, clsTotal number of mallocs.
go_memstats_mcache_inuse_bytesgaugejob, ins, ip, instance, clsNumber of bytes in use by mcache structures.
go_memstats_mcache_sys_bytesgaugejob, ins, ip, instance, clsNumber of bytes used for mcache structures obtained from system.
go_memstats_mspan_inuse_bytesgaugejob, ins, ip, instance, clsNumber of bytes in use by mspan structures.
go_memstats_mspan_sys_bytesgaugejob, ins, ip, instance, clsNumber of bytes used for mspan structures obtained from system.
go_memstats_next_gc_bytesgaugejob, ins, ip, instance, clsNumber of heap bytes when next garbage collection will take place.
go_memstats_other_sys_bytesgaugejob, ins, ip, instance, clsNumber of bytes used for other system allocations.
go_memstats_stack_inuse_bytesgaugejob, ins, ip, instance, clsNumber of bytes in use by the stack allocator.
go_memstats_stack_sys_bytesgaugejob, ins, ip, instance, clsNumber of bytes obtained from system for stack allocator.
go_memstats_sys_bytesgaugejob, ins, ip, instance, clsNumber of bytes obtained from system.
go_threadsgaugejob, ins, ip, instance, clsNumber of OS threads created.
patroni_cluster_unlockedgaugejob, ins, ip, instance, cls, scopeValue is 1 if the cluster is unlocked, 0 if locked.
patroni_dcs_last_seengaugejob, ins, ip, instance, cls, scopeEpoch timestamp when DCS was last contacted successfully by Patroni.
patroni_failsafe_mode_is_activegaugejob, ins, ip, instance, cls, scopeValue is 1 if failsafe mode is active, 0 if inactive.
patroni_is_pausedgaugejob, ins, ip, instance, cls, scopeValue is 1 if auto failover is disabled, 0 otherwise.
patroni_mastergaugejob, ins, ip, instance, cls, scopeValue is 1 if this node is the leader, 0 otherwise.
patroni_pending_restartgaugejob, ins, ip, instance, cls, scopeValue is 1 if the node needs a restart, 0 otherwise.
patroni_postgres_in_archive_recoverygaugejob, ins, ip, instance, cls, scopeValue is 1 if Postgres is replicating from archive, 0 otherwise.
patroni_postgres_runninggaugejob, ins, ip, instance, cls, scopeValue is 1 if Postgres is running, 0 otherwise.
patroni_postgres_server_versiongaugejob, ins, ip, instance, cls, scopeVersion of Postgres (if running), 0 otherwise.
patroni_postgres_streaminggaugejob, ins, ip, instance, cls, scopeValue is 1 if Postgres is streaming, 0 otherwise.
patroni_postgres_timelinecounterjob, ins, ip, instance, cls, scopePostgres timeline of this node (if running), 0 otherwise.
patroni_postmaster_start_timegaugejob, ins, ip, instance, cls, scopeEpoch seconds since Postgres started.
patroni_primarygaugejob, ins, ip, instance, cls, scopeValue is 1 if this node is the leader, 0 otherwise.
patroni_replicagaugejob, ins, ip, instance, cls, scopeValue is 1 if this node is a replica, 0 otherwise.
patroni_standby_leadergaugejob, ins, ip, instance, cls, scopeValue is 1 if this node is the standby_leader, 0 otherwise.
patroni_sync_standbygaugejob, ins, ip, instance, cls, scopeValue is 1 if this node is a sync standby replica, 0 otherwise.
patroni_versiongaugejob, ins, ip, instance, cls, scopePatroni semver without periods.
patroni_xlog_locationcounterjob, ins, ip, instance, cls, scopeCurrent location of the Postgres transaction log, 0 if this node is not the leader.
patroni_xlog_pausedgaugejob, ins, ip, instance, cls, scopeValue is 1 if the Postgres xlog is paused, 0 otherwise.
patroni_xlog_received_locationcounterjob, ins, ip, instance, cls, scopeCurrent location of the received Postgres transaction log, 0 if this node is not a replica.
patroni_xlog_replayed_locationcounterjob, ins, ip, instance, cls, scopeCurrent location of the replayed Postgres transaction log, 0 if this node is not a replica.
patroni_xlog_replayed_timestampgaugejob, ins, ip, instance, cls, scopeCurrent timestamp of the replayed Postgres transaction log, 0 if null.
pg_activity_countgaugedatname, state, job, ins, ip, instance, clsCount of connection among (datname,state)
pg_activity_max_conn_durationgaugedatname, state, job, ins, ip, instance, clsMax backend session duration since state change among (datname, state)
pg_activity_max_durationgaugedatname, state, job, ins, ip, instance, clsMax duration since last state change among (datname, state)
pg_activity_max_tx_durationgaugedatname, state, job, ins, ip, instance, clsMax transaction duration since state change among (datname, state)
pg_archiver_failed_countcounterjob, ins, ip, instance, clsNumber of failed attempts for archiving WAL files
pg_archiver_finish_countcounterjob, ins, ip, instance, clsNumber of WAL files that have been successfully archived
pg_archiver_last_failed_timecounterjob, ins, ip, instance, clsTime of the last failed archival operation
pg_archiver_last_finish_timecounterjob, ins, ip, instance, clsTime of the last successful archive operation
pg_archiver_reset_timegaugejob, ins, ip, instance, clsTime at which archive statistics were last reset
pg_backend_countgaugetype, job, ins, ip, instance, clsDatabase backend process count by backend_type
pg_bgwriter_buffers_alloccounterjob, ins, ip, instance, clsNumber of buffers allocated
pg_bgwriter_buffers_backendcounterjob, ins, ip, instance, clsNumber of buffers written directly by a backend
pg_bgwriter_buffers_backend_fsynccounterjob, ins, ip, instance, clsNumber of times a backend had to execute its own fsync call
pg_bgwriter_buffers_checkpointcounterjob, ins, ip, instance, clsNumber of buffers written during checkpoints
pg_bgwriter_buffers_cleancounterjob, ins, ip, instance, clsNumber of buffers written by the background writer
pg_bgwriter_checkpoint_sync_timecounterjob, ins, ip, instance, clsTotal amount of time that has been spent in the portion of checkpoint processing where files are synchronized to disk, in seconds
pg_bgwriter_checkpoint_write_timecounterjob, ins, ip, instance, clsTotal amount of time that has been spent in the portion of checkpoint processing where files are written to disk, in seconds
pg_bgwriter_checkpoints_reqcounterjob, ins, ip, instance, clsNumber of requested checkpoints that have been performed
pg_bgwriter_checkpoints_timedcounterjob, ins, ip, instance, clsNumber of scheduled checkpoints that have been performed
pg_bgwriter_maxwritten_cleancounterjob, ins, ip, instance, clsNumber of times the background writer stopped a cleaning scan because it had written too many buffers
pg_bgwriter_reset_timecounterjob, ins, ip, instance, clsTime at which bgwriter statistics were last reset
pg_boot_timegaugejob, ins, ip, instance, clsunix timestamp when postmaster boot
pg_checkpoint_checkpoint_lsncounterjob, ins, ip, instance, clsLatest checkpoint location
pg_checkpoint_elapsegaugejob, ins, ip, instance, clsSeconds elapsed since latest checkpoint in seconds
pg_checkpoint_full_page_writesgaugejob, ins, ip, instance, clsLatest checkpoint’s full_page_writes enabled
pg_checkpoint_newest_commit_ts_xidcounterjob, ins, ip, instance, clsLatest checkpoint’s newestCommitTsXid
pg_checkpoint_next_multi_offsetcounterjob, ins, ip, instance, clsLatest checkpoint’s NextMultiOffset
pg_checkpoint_next_multixact_idcounterjob, ins, ip, instance, clsLatest checkpoint’s NextMultiXactId
pg_checkpoint_next_oidcounterjob, ins, ip, instance, clsLatest checkpoint’s NextOID
pg_checkpoint_next_xidcounterjob, ins, ip, instance, clsLatest checkpoint’s NextXID xid
pg_checkpoint_next_xid_epochcounterjob, ins, ip, instance, clsLatest checkpoint’s NextXID epoch
pg_checkpoint_oldest_active_xidcounterjob, ins, ip, instance, clsLatest checkpoint’s oldestActiveXID
pg_checkpoint_oldest_commit_ts_xidcounterjob, ins, ip, instance, clsLatest checkpoint’s oldestCommitTsXid
pg_checkpoint_oldest_multi_dbidgaugejob, ins, ip, instance, clsLatest checkpoint’s oldestMulti’s DB OID
pg_checkpoint_oldest_multi_xidcounterjob, ins, ip, instance, clsLatest checkpoint’s oldestMultiXid
pg_checkpoint_oldest_xidcounterjob, ins, ip, instance, clsLatest checkpoint’s oldestXID
pg_checkpoint_oldest_xid_dbidgaugejob, ins, ip, instance, clsLatest checkpoint’s oldestXID’s DB OID
pg_checkpoint_prev_tlicounterjob, ins, ip, instance, clsLatest checkpoint’s PrevTimeLineID
pg_checkpoint_redo_lsncounterjob, ins, ip, instance, clsLatest checkpoint’s REDO location
pg_checkpoint_timecounterjob, ins, ip, instance, clsTime of latest checkpoint
pg_checkpoint_tlicounterjob, ins, ip, instance, clsLatest checkpoint’s TimeLineID
pg_conf_reload_timegaugejob, ins, ip, instance, clsseconds since last configuration reload
pg_db_active_timecounterdatname, job, ins, ip, instance, clsTime spent executing SQL statements in this database, in seconds
pg_db_agegaugedatname, job, ins, ip, instance, clsAge of database calculated from datfrozenxid
pg_db_allow_conngaugedatname, job, ins, ip, instance, clsIf false(0) then no one can connect to this database.
pg_db_blk_read_timecounterdatname, job, ins, ip, instance, clsTime spent reading data file blocks by backends in this database, in seconds
pg_db_blk_write_timecounterdatname, job, ins, ip, instance, clsTime spent writing data file blocks by backends in this database, in seconds
pg_db_blks_accesscounterdatname, job, ins, ip, instance, clsNumber of times disk blocks that accessed read+hit
pg_db_blks_hitcounterdatname, job, ins, ip, instance, clsNumber of times disk blocks were found already in the buffer cache
pg_db_blks_readcounterdatname, job, ins, ip, instance, clsNumber of disk blocks read in this database
pg_db_cks_fail_timegaugedatname, job, ins, ip, instance, clsTime at which the last data page checksum failure was detected in this database
pg_db_cks_failscounterdatname, job, ins, ip, instance, clsNumber of data page checksum failures detected in this database, -1 for not enabled
pg_db_confl_confl_bufferpincounterdatname, job, ins, ip, instance, clsNumber of queries in this database that have been canceled due to pinned buffers
pg_db_confl_confl_deadlockcounterdatname, job, ins, ip, instance, clsNumber of queries in this database that have been canceled due to deadlocks
pg_db_confl_confl_lockcounterdatname, job, ins, ip, instance, clsNumber of queries in this database that have been canceled due to lock timeouts
pg_db_confl_confl_snapshotcounterdatname, job, ins, ip, instance, clsNumber of queries in this database that have been canceled due to old snapshots
pg_db_confl_confl_tablespacecounterdatname, job, ins, ip, instance, clsNumber of queries in this database that have been canceled due to dropped tablespaces
pg_db_conflictscounterdatname, job, ins, ip, instance, clsNumber of queries canceled due to conflicts with recovery in this database
pg_db_conn_limitgaugedatname, job, ins, ip, instance, clsSets maximum number of concurrent connections that can be made to this database. -1 means no limit.
pg_db_datidgaugedatname, job, ins, ip, instance, clsOID of the database
pg_db_deadlockscounterdatname, job, ins, ip, instance, clsNumber of deadlocks detected in this database
pg_db_frozen_xidgaugedatname, job, ins, ip, instance, clsAll transaction IDs before this one have been frozened
pg_db_is_templategaugedatname, job, ins, ip, instance, clsIf true(1), then this database can be cloned by any user with CREATEDB privileges
pg_db_ixact_timecounterdatname, job, ins, ip, instance, clsTime spent idling while in a transaction in this database, in seconds
pg_db_numbackendsgaugedatname, job, ins, ip, instance, clsNumber of backends currently connected to this database
pg_db_reset_timecounterdatname, job, ins, ip, instance, clsTime at which database statistics were last reset
pg_db_session_timecounterdatname, job, ins, ip, instance, clsTime spent by database sessions in this database, in seconds
pg_db_sessionscounterdatname, job, ins, ip, instance, clsTotal number of sessions established to this database
pg_db_sessions_abandonedcounterdatname, job, ins, ip, instance, clsNumber of database sessions to this database that were terminated because connection to the client was lost
pg_db_sessions_fatalcounterdatname, job, ins, ip, instance, clsNumber of database sessions to this database that were terminated by fatal errors
pg_db_sessions_killedcounterdatname, job, ins, ip, instance, clsNumber of database sessions to this database that were terminated by operator intervention
pg_db_temp_bytescounterdatname, job, ins, ip, instance, clsTotal amount of data written to temporary files by queries in this database.
pg_db_temp_filescounterdatname, job, ins, ip, instance, clsNumber of temporary files created by queries in this database
pg_db_tup_deletedcounterdatname, job, ins, ip, instance, clsNumber of rows deleted by queries in this database
pg_db_tup_fetchedcounterdatname, job, ins, ip, instance, clsNumber of rows fetched by queries in this database
pg_db_tup_insertedcounterdatname, job, ins, ip, instance, clsNumber of rows inserted by queries in this database
pg_db_tup_modifiedcounterdatname, job, ins, ip, instance, clsNumber of rows modified by queries in this database
pg_db_tup_returnedcounterdatname, job, ins, ip, instance, clsNumber of rows returned by queries in this database
pg_db_tup_updatedcounterdatname, job, ins, ip, instance, clsNumber of rows updated by queries in this database
pg_db_xact_commitcounterdatname, job, ins, ip, instance, clsNumber of transactions in this database that have been committed
pg_db_xact_rollbackcounterdatname, job, ins, ip, instance, clsNumber of transactions in this database that have been rolled back
pg_db_xact_totalcounterdatname, job, ins, ip, instance, clsNumber of transactions in this database
pg_downstream_countgaugestate, job, ins, ip, instance, clsCount of corresponding state
pg_exporter_last_scrape_timegaugejob, ins, ip, instance, clsseconds exporter spending on scrapping
pg_exporter_query_cache_ttlgaugedatname, query, job, ins, ip, instance, clstimes to live of query cache
pg_exporter_query_scrape_durationgaugedatname, query, job, ins, ip, instance, clsseconds query spending on scrapping
pg_exporter_query_scrape_error_countgaugedatname, query, job, ins, ip, instance, clstimes the query failed
pg_exporter_query_scrape_hit_countgaugedatname, query, job, ins, ip, instance, clsnumbers been scrapped from this query
pg_exporter_query_scrape_metric_countgaugedatname, query, job, ins, ip, instance, clsnumbers of metrics been scrapped from this query
pg_exporter_query_scrape_total_countgaugedatname, query, job, ins, ip, instance, clstimes exporter server was scraped for metrics
pg_exporter_scrape_durationgaugejob, ins, ip, instance, clsseconds exporter spending on scrapping
pg_exporter_scrape_error_countcounterjob, ins, ip, instance, clstimes exporter was scraped for metrics and failed
pg_exporter_scrape_total_countcounterjob, ins, ip, instance, clstimes exporter was scraped for metrics
pg_exporter_server_scrape_durationgaugedatname, job, ins, ip, instance, clsseconds exporter server spending on scrapping
pg_exporter_server_scrape_error_countUnknowndatname, job, ins, ip, instance, clsN/A
pg_exporter_server_scrape_total_countgaugedatname, job, ins, ip, instance, clstimes exporter server was scraped for metrics
pg_exporter_server_scrape_total_secondsgaugedatname, job, ins, ip, instance, clsseconds exporter server spending on scrapping
pg_exporter_upgaugejob, ins, ip, instance, clsalways be 1 if your could retrieve metrics
pg_exporter_uptimegaugejob, ins, ip, instance, clsseconds since exporter primary server inited
pg_flush_lsncounterjob, ins, ip, instance, clsprimary only, location of current wal syncing
pg_func_callscounterdatname, funcname, job, ins, ip, instance, clsNumber of times this function has been called
pg_func_self_timecounterdatname, funcname, job, ins, ip, instance, clsTotal time spent in this function itself, not including other functions called by it, in ms
pg_func_total_timecounterdatname, funcname, job, ins, ip, instance, clsTotal time spent in this function and all other functions called by it, in ms
pg_in_recoverygaugejob, ins, ip, instance, clsserver is in recovery mode? 1 for yes 0 for no
pg_index_idx_blks_hitcounterdatname, relname, job, ins, relid, ip, instance, cls, idxnameNumber of buffer hits in this index
pg_index_idx_blks_readcounterdatname, relname, job, ins, relid, ip, instance, cls, idxnameNumber of disk blocks read from this index
pg_index_idx_scancounterdatname, relname, job, ins, relid, ip, instance, cls, idxnameNumber of index scans initiated on this index
pg_index_idx_tup_fetchcounterdatname, relname, job, ins, relid, ip, instance, cls, idxnameNumber of live table rows fetched by simple index scans using this index
pg_index_idx_tup_readcounterdatname, relname, job, ins, relid, ip, instance, cls, idxnameNumber of index entries returned by scans on this index
pg_index_relpagesgaugedatname, relname, job, ins, relid, ip, instance, cls, idxnameSize of the on-disk representation of this index in pages
pg_index_reltuplesgaugedatname, relname, job, ins, relid, ip, instance, cls, idxnameEstimate relation tuples
pg_insert_lsncounterjob, ins, ip, instance, clsprimary only, location of current wal inserting
pg_io_evictionscountertype, job, ins, object, ip, context, instance, clsNumber of times a block has been written out from a shared or local buffer
pg_io_extend_timecountertype, job, ins, object, ip, context, instance, clsTime spent in extend operations in seconds
pg_io_extendscountertype, job, ins, object, ip, context, instance, clsNumber of relation extend operations, each of the size specified in op_bytes.
pg_io_fsync_timecountertype, job, ins, object, ip, context, instance, clsTime spent in fsync operations in seconds
pg_io_fsyncscountertype, job, ins, object, ip, context, instance, clsNumber of fsync calls. These are only tracked in context normal
pg_io_hitscountertype, job, ins, object, ip, context, instance, clsThe number of times a desired block was found in a shared buffer.
pg_io_op_bytesgaugetype, job, ins, object, ip, context, instance, clsThe number of bytes per unit of I/O read, written, or extended. 8192 by default
pg_io_read_timecountertype, job, ins, object, ip, context, instance, clsTime spent in read operations in seconds
pg_io_readscountertype, job, ins, object, ip, context, instance, clsNumber of read operations, each of the size specified in op_bytes.
pg_io_reset_timegaugetype, job, ins, object, ip, context, instance, clsTimestamp at which these statistics were last reset
pg_io_reusescountertype, job, ins, object, ip, context, instance, clsThe number of times an existing buffer in reused
pg_io_write_timecountertype, job, ins, object, ip, context, instance, clsTime spent in write operations in seconds
pg_io_writeback_timecountertype, job, ins, object, ip, context, instance, clsTime spent in writeback operations in seconds
pg_io_writebackscountertype, job, ins, object, ip, context, instance, clsNumber of units of size op_bytes which the process requested the kernel write out to permanent storage.
pg_io_writescountertype, job, ins, object, ip, context, instance, clsNumber of write operations, each of the size specified in op_bytes.
pg_is_in_recoverygaugejob, ins, ip, instance, cls1 if in recovery mode
pg_is_wal_replay_pausedgaugejob, ins, ip, instance, cls1 if wal play paused
pg_laggaugejob, ins, ip, instance, clsreplica only, replication lag in seconds
pg_last_replay_timegaugejob, ins, ip, instance, clstime when last transaction been replayed
pg_lock_countgaugedatname, job, ins, ip, mode, instance, clsNumber of locks of corresponding mode and database
pg_lsncounterjob, ins, ip, instance, clslog sequence number, current write location
pg_meta_infogaugecls, extensions, version, job, ins, primary_conninfo, conf_path, hba_path, ip, cluster_id, instance, listen_port, wal_level, ver_num, cluster_name, data_dirconstant 1
pg_query_callscounterdatname, query, job, ins, ip, instance, clsNumber of times the statement was executed
pg_query_exec_timecounterdatname, query, job, ins, ip, instance, clsTotal time spent executing the statement, in seconds
pg_query_io_timecounterdatname, query, job, ins, ip, instance, clsTotal time the statement spent reading and writing blocks, in seconds
pg_query_rowscounterdatname, query, job, ins, ip, instance, clsTotal number of rows retrieved or affected by the statement
pg_query_sblk_dirtiedcounterdatname, query, job, ins, ip, instance, clsTotal number of shared blocks dirtied by the statement
pg_query_sblk_hitcounterdatname, query, job, ins, ip, instance, clsTotal number of shared block cache hits by the statement
pg_query_sblk_readcounterdatname, query, job, ins, ip, instance, clsTotal number of shared blocks read by the statement
pg_query_sblk_writtencounterdatname, query, job, ins, ip, instance, clsTotal number of shared blocks written by the statement
pg_query_wal_bytescounterdatname, query, job, ins, ip, instance, clsTotal amount of WAL bytes generated by the statement
pg_receive_lsncounterjob, ins, ip, instance, clsreplica only, location of wal synced to disk
pg_recovery_backup_end_lsncounterjob, ins, ip, instance, clsBackup end location
pg_recovery_backup_start_lsncounterjob, ins, ip, instance, clsBackup start location
pg_recovery_min_lsncounterjob, ins, ip, instance, clsMinimum recovery ending location
pg_recovery_min_timelinecounterjob, ins, ip, instance, clsMin recovery ending loc’s timeline
pg_recovery_prefetch_block_distancegaugejob, ins, ip, instance, clsHow many blocks ahead the prefetcher is looking
pg_recovery_prefetch_hitcounterjob, ins, ip, instance, clsNumber of blocks not prefetched because they were already in the buffer pool
pg_recovery_prefetch_io_depthgaugejob, ins, ip, instance, clsHow many prefetches have been initiated but are not yet known to have completed
pg_recovery_prefetch_prefetchcounterjob, ins, ip, instance, clsNumber of blocks prefetched because they were not in the buffer pool
pg_recovery_prefetch_reset_timecounterjob, ins, ip, instance, clsTime at which these recovery prefetch statistics were last reset
pg_recovery_prefetch_skip_fpwgaugejob, ins, ip, instance, clsNumber of blocks not prefetched because a full page image was included in the WAL
pg_recovery_prefetch_skip_initcounterjob, ins, ip, instance, clsNumber of blocks not prefetched because they would be zero-initialized
pg_recovery_prefetch_skip_newcounterjob, ins, ip, instance, clsNumber of blocks not prefetched because they didn’t exist yet
pg_recovery_prefetch_skip_repcounterjob, ins, ip, instance, clsNumber of blocks not prefetched because they were already recently prefetched
pg_recovery_prefetch_wal_distancegaugejob, ins, ip, instance, clsHow many bytes ahead the prefetcher is looking
pg_recovery_require_recordgaugejob, ins, ip, instance, clsEnd-of-backup record required
pg_recv_flush_lsncounterstate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portLast write-ahead log location already received and flushed to disk
pg_recv_flush_tlicounterstate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portTimeline number of last write-ahead log location received and flushed to disk
pg_recv_init_lsncounterstate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portFirst write-ahead log location used when WAL receiver is started
pg_recv_init_tlicounterstate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portFirst timeline number used when WAL receiver is started
pg_recv_msg_recv_timegaugestate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portReceipt time of last message received from origin WAL sender
pg_recv_msg_send_timegaugestate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portSend time of last message received from origin WAL sender
pg_recv_pidgaugestate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portProcess ID of the WAL receiver process
pg_recv_reported_lsncounterstate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portLast write-ahead log location reported to origin WAL sender
pg_recv_reported_timegaugestate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portTime of last write-ahead log location reported to origin WAL sender
pg_recv_timegaugestate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portTime of current snapshot
pg_recv_write_lsncounterstate, slot_name, job, ins, ip, instance, cls, sender_host, sender_portLast write-ahead log location already received and written to disk, but not flushed.
pg_relkind_countgaugedatname, job, ins, ip, instance, cls, relkindNumber of relations of corresponding relkind
pg_repl_backend_xmincounterpid, usename, address, job, ins, appname, ip, instance, clsThis standby’s xmin horizon reported by hot_standby_feedback.
pg_repl_client_portgaugepid, usename, address, job, ins, appname, ip, instance, clsTCP port number that the client is using for communication with this WAL sender, or -1 if a Unix socket is used
pg_repl_flush_diffgaugepid, usename, address, job, ins, appname, ip, instance, clsLast log position flushed to disk by this standby server diff with current lsn
pg_repl_flush_laggaugepid, usename, address, job, ins, appname, ip, instance, clsTime elapsed between flushing recent WAL locally and receiving notification that this standby server has written and flushed it
pg_repl_flush_lsncounterpid, usename, address, job, ins, appname, ip, instance, clsLast write-ahead log location flushed to disk by this standby server
pg_repl_launch_timecounterpid, usename, address, job, ins, appname, ip, instance, clsTime when this process was started, i.e., when the client connected to this WAL sender
pg_repl_lsncounterpid, usename, address, job, ins, appname, ip, instance, clsCurrent log position on this server
pg_repl_replay_diffgaugepid, usename, address, job, ins, appname, ip, instance, clsLast log position replayed into the database on this standby server diff with current lsn
pg_repl_replay_laggaugepid, usename, address, job, ins, appname, ip, instance, clsTime elapsed between flushing recent WAL locally and receiving notification that this standby server has written, flushed and applied it
pg_repl_replay_lsncounterpid, usename, address, job, ins, appname, ip, instance, clsLast write-ahead log location replayed into the database on this standby server
pg_repl_reply_timegaugepid, usename, address, job, ins, appname, ip, instance, clsSend time of last reply message received from standby server
pg_repl_sent_diffgaugepid, usename, address, job, ins, appname, ip, instance, clsLast log position sent to this standby server diff with current lsn
pg_repl_sent_lsncounterpid, usename, address, job, ins, appname, ip, instance, clsLast write-ahead log location sent on this connection
pg_repl_stategaugepid, usename, address, job, ins, appname, ip, instance, clsCurrent WAL sender encoded state 0-4 for streaming startup catchup backup stopping
pg_repl_sync_prioritygaugepid, usename, address, job, ins, appname, ip, instance, clsPriority of this standby server for being chosen as the synchronous standby
pg_repl_sync_stategaugepid, usename, address, job, ins, appname, ip, instance, clsEncoded synchronous state of this standby server, 0-3 for async potential sync quorum
pg_repl_timecounterpid, usename, address, job, ins, appname, ip, instance, clsCurrent timestamp in unix epoch
pg_repl_write_diffgaugepid, usename, address, job, ins, appname, ip, instance, clsLast log position written to disk by this standby server diff with current lsn
pg_repl_write_laggaugepid, usename, address, job, ins, appname, ip, instance, clsTime elapsed between flushing recent WAL locally and receiving notification that this standby server has written it
pg_repl_write_lsncounterpid, usename, address, job, ins, appname, ip, instance, clsLast write-ahead log location written to disk by this standby server
pg_replay_lsncounterjob, ins, ip, instance, clsreplica only, location of wal applied
pg_seq_blks_hitcounterdatname, job, ins, ip, instance, cls, seqnameNumber of buffer hits in this sequence
pg_seq_blks_readcounterdatname, job, ins, ip, instance, cls, seqnameNumber of disk blocks read from this sequence
pg_seq_last_valuecounterdatname, job, ins, ip, instance, cls, seqnameThe last sequence value written to disk
pg_setting_block_sizegaugejob, ins, ip, instance, clspg page block size, 8192 by default
pg_setting_data_checksumsgaugejob, ins, ip, instance, clswhether data checksum is enabled, 1 enabled 0 disabled
pg_setting_max_connectionsgaugejob, ins, ip, instance, clsnumber of concurrent connections to the database server
pg_setting_max_locks_per_transactiongaugejob, ins, ip, instance, clsno more than this many distinct objects can be locked at any one time
pg_setting_max_prepared_transactionsgaugejob, ins, ip, instance, clsmaximum number of transactions that can be in the prepared state simultaneously
pg_setting_max_replication_slotsgaugejob, ins, ip, instance, clsmaximum number of replication slots
pg_setting_max_wal_sendersgaugejob, ins, ip, instance, clsmaximum number of concurrent connections from standby servers
pg_setting_max_worker_processesgaugejob, ins, ip, instance, clsmaximum number of background processes that the system can support
pg_setting_wal_log_hintsgaugejob, ins, ip, instance, clswhether wal_log_hints is enabled, 1 enabled 0 disabled
pg_size_bytesgaugedatname, job, ins, ip, instance, clsFile size in bytes
pg_slot_activegaugeslot_name, job, ins, ip, instance, clsTrue(1) if this slot is currently actively being used
pg_slot_catalog_xmincounterslot_name, job, ins, ip, instance, clsThe oldest transaction affecting the system catalogs that this slot needs the database to retain.
pg_slot_confirm_lsncounterslot_name, job, ins, ip, instance, clsThe address (LSN) up to which the logical slot’s consumer has confirmed receiving data.
pg_slot_reset_timecounterslot_name, job, ins, ip, instance, clsWhen statistics were last reset
pg_slot_restart_lsncounterslot_name, job, ins, ip, instance, clsThe address (LSN) of oldest WAL which still might be required by the consumer of this slot
pg_slot_retained_bytesgaugeslot_name, job, ins, ip, instance, clsSize of bytes that retained for this slot
pg_slot_safe_wal_sizegaugeslot_name, job, ins, ip, instance, clsbytes that can be written to WAL which will not make slot into lost
pg_slot_spill_bytescounterslot_name, job, ins, ip, instance, clsBytes that spilled to disk due to logical decode mem exceeding
pg_slot_spill_countcounterslot_name, job, ins, ip, instance, clsXacts that spilled to disk due to logical decode mem exceeding (a xact can be spilled multiple times)
pg_slot_spill_txnscounterslot_name, job, ins, ip, instance, clsXacts that spilled to disk due to logical decode mem exceeding (subtrans included)
pg_slot_stream_bytescounterslot_name, job, ins, ip, instance, clsBytes that streamed to decoding output plugin after mem exceed
pg_slot_stream_countcounterslot_name, job, ins, ip, instance, clsXacts that streamed to decoding output plugin after mem exceed (a xact can be streamed multiple times)
pg_slot_stream_txnscounterslot_name, job, ins, ip, instance, clsXacts that streamed to decoding output plugin after mem exceed
pg_slot_temporarygaugeslot_name, job, ins, ip, instance, clsTrue(1) if this is a temporary replication slot.
pg_slot_total_bytescounterslot_name, job, ins, ip, instance, clsNumber of decoded bytes sent to the decoding output plugin for this slot
pg_slot_total_txnscounterslot_name, job, ins, ip, instance, clsNumber of decoded xacts sent to the decoding output plugin for this slot
pg_slot_wal_statusgaugeslot_name, job, ins, ip, instance, clsWAL reserve status 0-3 means reserved,extended,unreserved,lost, -1 means other
pg_slot_xmincounterslot_name, job, ins, ip, instance, clsThe oldest transaction that this slot needs the database to retain.
pg_slru_blks_existscounterjob, ins, ip, instance, clsNumber of blocks checked for existence for this SLRU
pg_slru_blks_hitcounterjob, ins, ip, instance, clsNumber of times disk blocks were found already in the SLRU, so that a read was not necessary
pg_slru_blks_readcounterjob, ins, ip, instance, clsNumber of disk blocks read for this SLRU
pg_slru_blks_writtencounterjob, ins, ip, instance, clsNumber of disk blocks written for this SLRU
pg_slru_blks_zeroedcounterjob, ins, ip, instance, clsNumber of blocks zeroed during initializations
pg_slru_flushescounterjob, ins, ip, instance, clsNumber of flushes of dirty data for this SLRU
pg_slru_reset_timecounterjob, ins, ip, instance, clsTime at which these statistics were last reset
pg_slru_truncatescounterjob, ins, ip, instance, clsNumber of truncates for this SLRU
pg_ssl_disabledgaugejob, ins, ip, instance, clsNumber of client connection that does not use ssl
pg_ssl_enabledgaugejob, ins, ip, instance, clsNumber of client connection that use ssl
pg_sync_standby_enabledgaugejob, ins, ip, names, instance, clsSynchronous commit enabled, 1 if enabled, 0 if disabled
pg_table_agegaugedatname, relname, job, ins, ip, instance, clsAge of this table in vacuum cycles
pg_table_analyze_countcounterdatname, relname, job, ins, ip, instance, clsNumber of times this table has been manually analyzed
pg_table_autoanalyze_countcounterdatname, relname, job, ins, ip, instance, clsNumber of times this table has been analyzed by the autovacuum daemon
pg_table_autovacuum_countcounterdatname, relname, job, ins, ip, instance, clsNumber of times this table has been vacuumed by the autovacuum daemon
pg_table_frozenxidcounterdatname, relname, job, ins, ip, instance, clsAll txid before this have been frozen on this table
pg_table_heap_blks_hitcounterdatname, relname, job, ins, ip, instance, clsNumber of buffer hits in this table
pg_table_heap_blks_readcounterdatname, relname, job, ins, ip, instance, clsNumber of disk blocks read from this table
pg_table_idx_blks_hitcounterdatname, relname, job, ins, ip, instance, clsNumber of buffer hits in all indexes on this table
pg_table_idx_blks_readcounterdatname, relname, job, ins, ip, instance, clsNumber of disk blocks read from all indexes on this table
pg_table_idx_scancounterdatname, relname, job, ins, ip, instance, clsNumber of index scans initiated on this table
pg_table_idx_tup_fetchcounterdatname, relname, job, ins, ip, instance, clsNumber of live rows fetched by index scans
pg_table_kindgaugedatname, relname, job, ins, ip, instance, clsRelation kind r/table/114
pg_table_n_dead_tupgaugedatname, relname, job, ins, ip, instance, clsEstimated number of dead rows
pg_table_n_ins_since_vacuumgaugedatname, relname, job, ins, ip, instance, clsEstimated number of rows inserted since this table was last vacuumed
pg_table_n_live_tupgaugedatname, relname, job, ins, ip, instance, clsEstimated number of live rows
pg_table_n_mod_since_analyzegaugedatname, relname, job, ins, ip, instance, clsEstimated number of rows modified since this table was last analyzed
pg_table_n_tup_delcounterdatname, relname, job, ins, ip, instance, clsNumber of rows deleted
pg_table_n_tup_hot_updcounterdatname, relname, job, ins, ip, instance, clsNumber of rows HOT updated (i.e with no separate index update required)
pg_table_n_tup_inscounterdatname, relname, job, ins, ip, instance, clsNumber of rows inserted
pg_table_n_tup_modcounterdatname, relname, job, ins, ip, instance, clsNumber of rows modified (insert + update + delete)
pg_table_n_tup_newpage_updcounterdatname, relname, job, ins, ip, instance, clsNumber of rows updated where the successor version goes onto a new heap page
pg_table_n_tup_updcounterdatname, relname, job, ins, ip, instance, clsNumber of rows updated (includes HOT updated rows)
pg_table_ncolsgaugedatname, relname, job, ins, ip, instance, clsNumber of columns in the table
pg_table_pagesgaugedatname, relname, job, ins, ip, instance, clsSize of the on-disk representation of this table in pages
pg_table_relidgaugedatname, relname, job, ins, ip, instance, clsRelation oid of this table
pg_table_seq_scancounterdatname, relname, job, ins, ip, instance, clsNumber of sequential scans initiated on this table
pg_table_seq_tup_readcounterdatname, relname, job, ins, ip, instance, clsNumber of live rows fetched by sequential scans
pg_table_size_bytesgaugedatname, relname, job, ins, ip, instance, clsTotal bytes of this table (including toast, index, toast index)
pg_table_size_indexsizegaugedatname, relname, job, ins, ip, instance, clsBytes of all related indexes of this table
pg_table_size_relsizegaugedatname, relname, job, ins, ip, instance, clsBytes of this table itself (main, vm, fsm)
pg_table_size_toastsizegaugedatname, relname, job, ins, ip, instance, clsBytes of toast tables of this table
pg_table_tbl_scancounterdatname, relname, job, ins, ip, instance, clsNumber of scans initiated on this table
pg_table_tup_readcounterdatname, relname, job, ins, ip, instance, clsNumber of live rows fetched by scans
pg_table_tuplescounterdatname, relname, job, ins, ip, instance, clsAll txid before this have been frozen on this table
pg_table_vacuum_countcounterdatname, relname, job, ins, ip, instance, clsNumber of times this table has been manually vacuumed (not counting VACUUM FULL)
pg_timestampgaugejob, ins, ip, instance, clsdatabase current timestamp
pg_upgaugejob, ins, ip, instance, clslast scrape was able to connect to the server: 1 for yes, 0 for no
pg_uptimegaugejob, ins, ip, instance, clsseconds since postmaster start
pg_versiongaugejob, ins, ip, instance, clsserver version number
pg_wait_countgaugedatname, job, ins, event, ip, instance, clsCount of WaitEvent on target database
pg_wal_buffers_fullcounterjob, ins, ip, instance, clsNumber of times WAL data was written to disk because WAL buffers became full
pg_wal_bytescounterjob, ins, ip, instance, clsTotal amount of WAL generated in bytes
pg_wal_fpicounterjob, ins, ip, instance, clsTotal number of WAL full page images generated
pg_wal_recordscounterjob, ins, ip, instance, clsTotal number of WAL records generated
pg_wal_reset_timecounterjob, ins, ip, instance, clsWhen statistics were last reset
pg_wal_synccounterjob, ins, ip, instance, clsNumber of times WAL files were synced to disk via issue_xlog_fsync request
pg_wal_sync_timecounterjob, ins, ip, instance, clsTotal amount of time spent syncing WAL files to disk via issue_xlog_fsync request, in seconds
pg_wal_writecounterjob, ins, ip, instance, clsNumber of times WAL buffers were written out to disk via XLogWrite request.
pg_wal_write_timecounterjob, ins, ip, instance, clsTotal amount of time spent writing WAL buffers to disk via XLogWrite request in seconds
pg_write_lsncounterjob, ins, ip, instance, clsprimary only, location of current wal writing
pg_xact_xmaxcounterjob, ins, ip, instance, clsFirst as-yet-unassigned txid. txid >= this are invisible.
pg_xact_xmincounterjob, ins, ip, instance, clsEarliest txid that is still active
pg_xact_xnumgaugejob, ins, ip, instance, clsCurrent active transaction count
pgbouncer_database_current_connectionsgaugedatname, job, ins, ip, instance, host, cls, real_datname, portCurrent number of connections for this database
pgbouncer_database_disabledgaugedatname, job, ins, ip, instance, host, cls, real_datname, portTrue(1) if this database is currently disabled, else 0
pgbouncer_database_max_connectionsgaugedatname, job, ins, ip, instance, host, cls, real_datname, portMaximum number of allowed connections for this database
pgbouncer_database_min_pool_sizegaugedatname, job, ins, ip, instance, host, cls, real_datname, portMinimum number of server connections
pgbouncer_database_pausedgaugedatname, job, ins, ip, instance, host, cls, real_datname, portTrue(1) if this database is currently paused, else 0
pgbouncer_database_pool_sizegaugedatname, job, ins, ip, instance, host, cls, real_datname, portMaximum number of server connections
pgbouncer_database_reserve_poolgaugedatname, job, ins, ip, instance, host, cls, real_datname, portMaximum number of additional connections for this database
pgbouncer_exporter_last_scrape_timegaugejob, ins, ip, instance, clsseconds exporter spending on scrapping
pgbouncer_exporter_query_cache_ttlgaugedatname, query, job, ins, ip, instance, clstimes to live of query cache
pgbouncer_exporter_query_scrape_durationgaugedatname, query, job, ins, ip, instance, clsseconds query spending on scrapping
pgbouncer_exporter_query_scrape_error_countgaugedatname, query, job, ins, ip, instance, clstimes the query failed
pgbouncer_exporter_query_scrape_hit_countgaugedatname, query, job, ins, ip, instance, clsnumbers been scrapped from this query
pgbouncer_exporter_query_scrape_metric_countgaugedatname, query, job, ins, ip, instance, clsnumbers of metrics been scrapped from this query
pgbouncer_exporter_query_scrape_total_countgaugedatname, query, job, ins, ip, instance, clstimes exporter server was scraped for metrics
pgbouncer_exporter_scrape_durationgaugejob, ins, ip, instance, clsseconds exporter spending on scrapping
pgbouncer_exporter_scrape_error_countcounterjob, ins, ip, instance, clstimes exporter was scraped for metrics and failed
pgbouncer_exporter_scrape_total_countcounterjob, ins, ip, instance, clstimes exporter was scraped for metrics
pgbouncer_exporter_server_scrape_durationgaugedatname, job, ins, ip, instance, clsseconds exporter server spending on scrapping
pgbouncer_exporter_server_scrape_total_countgaugedatname, job, ins, ip, instance, clstimes exporter server was scraped for metrics
pgbouncer_exporter_server_scrape_total_secondsgaugedatname, job, ins, ip, instance, clsseconds exporter server spending on scrapping
pgbouncer_exporter_upgaugejob, ins, ip, instance, clsalways be 1 if your could retrieve metrics
pgbouncer_exporter_uptimegaugejob, ins, ip, instance, clsseconds since exporter primary server inited
pgbouncer_in_recoverygaugejob, ins, ip, instance, clsserver is in recovery mode? 1 for yes 0 for no
pgbouncer_list_itemsgaugejob, ins, ip, instance, list, clsNumber of corresponding pgbouncer object
pgbouncer_pool_active_cancel_clientsgaugedatname, job, ins, ip, instance, user, cls, pool_modeClient connections that have forwarded query cancellations to the server and are waiting for the server response.
pgbouncer_pool_active_cancel_serversgaugedatname, job, ins, ip, instance, user, cls, pool_modeServer connections that are currently forwarding a cancel request
pgbouncer_pool_active_clientsgaugedatname, job, ins, ip, instance, user, cls, pool_modeClient connections that are linked to server connection and can process queries
pgbouncer_pool_active_serversgaugedatname, job, ins, ip, instance, user, cls, pool_modeServer connections that are linked to a client
pgbouncer_pool_cancel_clientsgaugedatname, job, ins, ip, instance, user, cls, pool_modeClient connections that have not forwarded query cancellations to the server yet.
pgbouncer_pool_cancel_serversgaugedatname, job, ins, ip, instance, user, cls, pool_modecancel requests have completed that were sent to cancel a query on this server
pgbouncer_pool_idle_serversgaugedatname, job, ins, ip, instance, user, cls, pool_modeServer connections that are unused and immediately usable for client queries
pgbouncer_pool_login_serversgaugedatname, job, ins, ip, instance, user, cls, pool_modeServer connections currently in the process of logging in
pgbouncer_pool_maxwaitgaugedatname, job, ins, ip, instance, user, cls, pool_modeHow long the first(oldest) client in the queue has waited, in seconds, key metric
pgbouncer_pool_maxwait_usgaugedatname, job, ins, ip, instance, user, cls, pool_modeMicrosecond part of the maximum waiting time.
pgbouncer_pool_tested_serversgaugedatname, job, ins, ip, instance, user, cls, pool_modeServer connections that are currently running reset or check query
pgbouncer_pool_used_serversgaugedatname, job, ins, ip, instance, user, cls, pool_modeServer connections that have been idle for more than server_check_delay (means have to run check query)
pgbouncer_pool_waiting_clientsgaugedatname, job, ins, ip, instance, user, cls, pool_modeClient connections that have sent queries but have not yet got a server connection
pgbouncer_stat_avg_query_countgaugedatname, job, ins, ip, instance, clsAverage queries per second in last stat period
pgbouncer_stat_avg_query_timegaugedatname, job, ins, ip, instance, clsAverage query duration, in seconds
pgbouncer_stat_avg_recvgaugedatname, job, ins, ip, instance, clsAverage received (from clients) bytes per second
pgbouncer_stat_avg_sentgaugedatname, job, ins, ip, instance, clsAverage sent (to clients) bytes per second
pgbouncer_stat_avg_wait_timegaugedatname, job, ins, ip, instance, clsTime spent by clients waiting for a server, in seconds (average per second).
pgbouncer_stat_avg_xact_countgaugedatname, job, ins, ip, instance, clsAverage transactions per second in last stat period
pgbouncer_stat_avg_xact_timegaugedatname, job, ins, ip, instance, clsAverage transaction duration, in seconds
pgbouncer_stat_total_query_countgaugedatname, job, ins, ip, instance, clsTotal number of SQL queries pooled by pgbouncer
pgbouncer_stat_total_query_timecounterdatname, job, ins, ip, instance, clsTotal number of seconds spent when executing queries
pgbouncer_stat_total_receivedcounterdatname, job, ins, ip, instance, clsTotal volume in bytes of network traffic received by pgbouncer
pgbouncer_stat_total_sentcounterdatname, job, ins, ip, instance, clsTotal volume in bytes of network traffic sent by pgbouncer
pgbouncer_stat_total_wait_timecounterdatname, job, ins, ip, instance, clsTime spent by clients waiting for a server, in seconds
pgbouncer_stat_total_xact_countgaugedatname, job, ins, ip, instance, clsTotal number of SQL transactions pooled by pgbouncer
pgbouncer_stat_total_xact_timecounterdatname, job, ins, ip, instance, clsTotal number of seconds spent when in a transaction
pgbouncer_upgaugejob, ins, ip, instance, clslast scrape was able to connect to the server: 1 for yes, 0 for no
pgbouncer_versiongaugejob, ins, ip, instance, clsserver version number
process_cpu_seconds_totalcounterjob, ins, ip, instance, clsTotal user and system CPU time spent in seconds.
process_max_fdsgaugejob, ins, ip, instance, clsMaximum number of open file descriptors.
process_open_fdsgaugejob, ins, ip, instance, clsNumber of open file descriptors.
process_resident_memory_bytesgaugejob, ins, ip, instance, clsResident memory size in bytes.
process_start_time_secondsgaugejob, ins, ip, instance, clsStart time of the process since unix epoch in seconds.
process_virtual_memory_bytesgaugejob, ins, ip, instance, clsVirtual memory size in bytes.
process_virtual_memory_max_bytesgaugejob, ins, ip, instance, clsMaximum amount of virtual memory available in bytes.
promhttp_metric_handler_requests_in_flightgaugejob, ins, ip, instance, clsCurrent number of scrapes being served.
promhttp_metric_handler_requests_totalcountercode, job, ins, ip, instance, clsTotal number of scrapes by HTTP status code.
scrape_duration_secondsUnknownjob, ins, ip, instance, clsN/A
scrape_samples_post_metric_relabelingUnknownjob, ins, ip, instance, clsN/A
scrape_samples_scrapedUnknownjob, ins, ip, instance, clsN/A
scrape_series_addedUnknownjob, ins, ip, instance, clsN/A
upUnknownjob, ins, ip, instance, clsN/A

Recording Metric Index

The following groups list every name and expression from the rule file. Use page search to locate a metric. If rules have changed, use the files deployed to /infra/rules/ as the authority.

PostgreSQL: 233 recording rules
Recorded MetricExpression
pg:ins:cpu_countnode:ins:cpu_count + on(ip) group_right() pg_up * 0
pg:cls:cpu_countsum by (job, cls) (pg:ins:cpu_count)
pg:env:cpu_countsum by (job) (pg:cls:cpu_count)
pg:ins:cpu_usagenode:ins:cpu_usage_1m + on(ip) group_right() pg_up * 0
pg:ins:cpu_usage_1mnode:ins:cpu_usage_1m + on(ip) group_right() pg_up * 0
pg:ins:cpu_usage_5mnode:ins:cpu_usage_5m + on(ip) group_right() pg_up * 0
pg:ins:cpu_usage_15mnode:ins:cpu_usage_15m + on(ip) group_right() pg_up * 0
pg:cls:cpu_usagesum by (job, cls) (pg:ins:cpu_usage * pg:ins:cpu_count) / pg:cls:cpu_count
pg:cls:cpu_usage_1msum by (job, cls) (pg:ins:cpu_usage_1m * pg:ins:cpu_count) / pg:cls:cpu_count
pg:cls:cpu_usage_5msum by (job, cls) (pg:ins:cpu_usage_5m * pg:ins:cpu_count) / pg:cls:cpu_count
pg:cls:cpu_usage_15msum by (job, cls) (pg:ins:cpu_usage_15m * pg:ins:cpu_count) / pg:cls:cpu_count
pg:env:cpu_usagesum by (job) (pg:cls:cpu_usage * pg:cls:cpu_count) / pg:env:cpu_count
pg:env:cpu_usage_1msum by (job) (pg:cls:cpu_usage_1m * pg:cls:cpu_count) / pg:env:cpu_count
pg:env:cpu_usage_5msum by (job) (pg:cls:cpu_usage_5m * pg:cls:cpu_count) / pg:env:cpu_count
pg:env:cpu_usage_15msum by (job) (pg:cls:cpu_usage_15m * pg:cls:cpu_count) / pg:env:cpu_count
pg:ins:mem_sizenode_memory_MemTotal_bytes + on(ip) group_right() pg_up * 0
pg:ins:fs_sizesum by (ip)(node_filesystem_size_bytes{fstype!~"(n|root|tmp|fuse.juice)fs.*"}) + on(ip) group_right() pg_up * 0
pg:ins:space_usagemax by (ip)(node:fs:space_usage)+ on(ip) group_right() pg_up * 0
pg:ins:statuspg_up * 2 + (1 - pg_in_recovery)
pg:ins:is_leader1 - pg_in_recovery
pg:cls:leader(pg_in_recovery == 0) * 0 + 1
pg:ins:target_countcount by (job, cls, ins) (up{cls!="", ins!="", job='pgsql'})
pg:cls:sizesum by (job, cls) (group by (job, cls, ins, ip) (up{cls!="", ins!="", job='pgsql'}))
pg:cls:membersgroup by (job, cls, ins, ip) (up{cls!="", ins!="", job='pgsql'})
pg:cls:bridgescount without(appname,usename,address,pid) (pg_repl_lsn) and (pg_in_recovery == 1)
pg:cls:partitioncount by (job, cls) (pg_in_recovery == 0)
pg:cls:alive_countcount by (job, cls) (count by (cls, ins) (pg_up==1))
pg:cls:primary_countcount by (job, cls) (max by (cls, ins) (pg_in_recovery{}) == 0)
pg:cls:replica_countcount by (job, cls) (max by (cls, ins) (pg_in_recovery{}) == 1)
pg:cls:standby_countmax by (job, cls) (pg_sync_standby_enabled) > bool 0
pg:cls:bridge_countcount by (job, cls) (pg:cls:bridges)
pg:cls:sendermax by (job, cls, ins, ip, appname, usename, address, pid) (pg_repl_sync_state)
pg:cls:receivermax by ( job, cls, ip, appname, sender_host, sender_port, slot_name, state ) ( label_replace(pg_recv_flush_tli, "appname" , "$1", "ins", "(.*)" ) )
pg:ins:timelinepg_checkpoint_tli
pg:cls:timelinemax by (job, cls) (max_over_time(pg_checkpoint_tli{}[30s]))
pg:ins:sync_statemax by (job,cls,ins,instance) (label_replace(pg_repl_sync_state, "ins", "$1", "appname", "(.+)"))
pg:cls:sync_state(max by (job, cls) (pg:ins:sync_state)) > bool 0
pg:ins:lag_bytesmax without (address, appname, usename, pid) ( label_replace(pg_repl_replay_diff{appname!~'walreceiver|pg_receivewal'}, "ins", "$1", "appname", "(.+)") )
pg:cls:lag_bytesmax by (job, cls) (pg:ins:lag_bytes)
pg:env:lag_bytesmax by (job) (pg:cls:lag_bytes)
pg:ins:lag_secondsmax without (address, appname, usename, pid) ( label_replace(pg_repl_replay_lag{appname!~'walreceiver|pg_receivewal'}, "ins", "$1", "appname", "(.+)") )
pg:cls:lag_secondsmax by (job, cls) (pg:ins:lag_seconds)
pg:env:lag_secondsmax by (job) (pg:cls:lag_seconds)
pg:cls:slot_countcount by (job, cls) (pg_slot_active > bool 0)
pg:ins:slot_retained_bytesmax without (slot_name) (pg_slot_retained_bytes)
pg:cls:slot_retained_bytesmax by (job, cls) (pg:ins:slot_retained_bytes)
pg:db:xact_commit_rate1mrate(pg_db_xact_commit[1m])
pg:ins:xact_commit_rate1msum without(datname) (pg:db:xact_commit_rate1m)
pg:cls:xact_commit_rate1msum by (job, cls) (pg:ins:xact_commit_rate1m)
pg:env:xact_commit_rate1msum by (job) (pg:cls:xact_commit_rate1m)
pg:db:xact_commit_rate5mrate(pg_db_xact_commit[5m])
pg:ins:xact_commit_rate5msum without(datname) (pg:db:xact_commit_rate5m)
pg:cls:xact_commit_rate5msum by (job, cls) (pg:ins:xact_commit_rate5m)
pg:env:xact_commit_rate5msum by (job) (pg:cls:xact_commit_rate5m)
pg:db:xact_commit_rate15mrate(pg_db_xact_commit[15m])
pg:ins:xact_commit_rate15msum without(datname) (pg:db:xact_commit_rate15m)
pg:cls:xact_commit_rate15msum by (job, cls) (pg:ins:xact_commit_rate15m)
pg:env:xact_commit_rate15msum by (job) (pg:cls:xact_commit_rate15m)
pg:db:xact_rollback_rate1mrate(pg_db_xact_rollback[1m])
pg:ins:xact_rollback_rate1msum without(datname) (pg:db:xact_rollback_rate1m)
pg:cls:xact_rollback_rate1msum by (job, cls) (pg:ins:xact_rollback_rate1m)
pg:env:xact_rollback_rate1msum by (job) (pg:cls:xact_rollback_rate1m)
pg:db:xact_rollback_rate5mrate(pg_db_xact_rollback[5m])
pg:ins:xact_rollback_rate5msum without(datname) (pg:db:xact_rollback_rate5m)
pg:cls:xact_rollback_rate5msum by (job, cls) (pg:ins:xact_rollback_rate5m)
pg:env:xact_rollback_rate5msum by (job) (pg:cls:xact_rollback_rate5m)
pg:db:xact_rollback_rate15mrate(pg_db_xact_rollback[15m])
pg:ins:xact_rollback_rate15msum without(datname) (pg:db:xact_rollback_rate15m)
pg:cls:xact_rollback_rate15msum by (job, cls) (pg:ins:xact_rollback_rate15m)
pg:env:xact_rollback_rate15msum by (job) (pg:cls:xact_rollback_rate15m)
pg:db:xact_total_rate1mrate(pg_db_xact_total[1m])
pg:ins:xact_total_rate1msum without(datname) (pg:db:xact_total_rate1m)
pg:cls:xact_total_rate1msum by (job, cls) (pg:ins:xact_total_rate1m)
pg:env:xact_total_rate1msum by (job) (pg:cls:xact_total_rate1m)
pg:db:xact_total_rate5mrate(pg_db_xact_total[5m])
pg:ins:xact_total_rate5msum without(datname) (pg:db:xact_total_rate5m)
pg:cls:xact_total_rate5msum by (job, cls) (pg:ins:xact_total_rate5m)
pg:env:xact_total_rate5msum by (job) (pg:cls:xact_total_rate5m)
pg:db:xact_total_rate15mrate(pg_db_xact_total[15m])
pg:ins:xact_total_rate15msum without(datname) (pg:db:xact_total_rate15m)
pg:cls:xact_total_rate15msum by (job, cls) (pg:ins:xact_total_rate15m)
pg:env:xact_total_rate15msum by (job) (pg:cls:xact_total_rate15m)
pg:db:xact_total_sigma15mstddev_over_time(pg:db:xact_total_rate1m[15m])
pg:ins:xact_total_sigma15mstddev_over_time(pg:ins:xact_total_rate1m[15m])
pg:cls:xact_total_sigma15mstddev_over_time(pg:cls:xact_total_rate1m[15m])
pg:env:xact_total_sigma15mstddev_over_time(pg:env:xact_total_rate1m[15m])
pg:ins:lockssum without (datname) (pg_lock_count)
pg:cls:lockssum by (job, cls, mode) (pg:ins:locks)
pg:db:lock_countsum without (mode) (pg_lock_count)
pg:ins:lock_countsum without(mode) (pg:ins:locks)
pg:cls:lock_countsum without(mode) (pg:cls:locks)
pg:db:rlock_countsum without (mode) (pg_lock_count{mode="AccessShareLock"})
pg:ins:rlock_countsum without(datname) (pg:db:rlock_count)
pg:cls:rlock_countsum by (job, cls) (pg:ins:rlock_count)
pg:db:wlock_countsum without (mode) (pg_lock_count{mode=~"RowShareLock|RowExclusiveLock"})
pg:ins:wlock_countsum without(datname) (pg:db:wlock_count)
pg:cls:wlock_countsum by (job, cls) (pg:ins:wlock)
pg:db:xlock_countsum without (mode) (pg_lock_count{mode!~"AccessShareLock|RowShareLock|RowExclusiveLock"})
pg:ins:xlock_countsum without(datname) (pg:db:xlock_count)
pg:cls:xlock_countsum by (job, cls) (pg:ins:xlock_count)
pg:db:session_time_rate1mrate(pg_db_session_time[1m])
pg:ins:session_time_rate1msum without(datname) (pg:db:session_time_rate1m)
pg:cls:session_time_rate1msum by (job, cls) (pg:ins:session_time_rate1m)
pg:env:session_time_rate1msum by (job) (pg:cls:session_time_rate1m)
pg:db:ixact_time_rate1mrate(pg_db_ixact_time[1m])
pg:ins:ixact_time_rate1msum without(datname) (pg:db:ixact_time_rate1m)
pg:cls:ixact_time_rate1msum by (job, cls) (pg:ins:ixact_time_rate1m)
pg:env:ixact_time_rate1msum by (job) (pg:cls:ixact_time_rate1m)
pg:db:ixact_time_rate5mrate(pg_db_ixact_time[5m])
pg:ins:ixact_time_rate5msum without(datname) (pg:db:ixact_time_rate5m)
pg:cls:ixact_time_rate5msum by (job, cls) (pg:ins:ixact_time_rate5m)
pg:env:ixact_time_rate5msum by (job) (pg:cls:ixact_time_rate5m)
pg:db:ixact_time_rate15mrate(pg_db_ixact_time[15m])
pg:ins:ixact_time_rate15msum without(datname) (pg:db:ixact_time_rate15m)
pg:cls:ixact_time_rate15msum by (job, cls) (pg:ins:ixact_time_rate15m)
pg:env:ixact_time_rate15msum by (job) (pg:cls:ixact_time_rate15m)
pg:db:active_time_rate1mrate(pg_db_active_time[1m])
pg:ins:active_time_rate1msum without(datname) (pg:db:active_time_rate1m)
pg:cls:active_time_rate1msum by (job, cls) (pg:ins:active_time_rate1m)
pg:env:active_time_rate1msum by (job) (pg:cls:active_time_rate1m)
pg:db:active_time_rate5mrate(pg_db_active_time[5m])
pg:ins:active_time_rate5msum without(datname) (pg:db:active_time_rate5m)
pg:cls:active_time_rate5msum by (job, cls) (pg:ins:active_time_rate5m)
pg:env:active_time_rate5msum by (job) (pg:cls:active_time_rate5m)
pg:db:active_time_rate15mrate(pg_db_active_time[15m])
pg:ins:active_time_rate15msum without(datname) (pg:db:active_time_rate15m)
pg:cls:active_time_rate15msum by (job, cls) (pg:ins:active_time_rate15m)
pg:env:active_time_rate15msum by (job) (pg:cls:active_time_rate15m)
pg:ins:load1pg:ins:active_time_rate1m / pg:ins:cpu_count or (0 * pg_up - 1)
pg:ins:load5pg:ins:active_time_rate5m / pg:ins:cpu_count or (0 * pg_up - 1)
pg:ins:load15pg:ins:active_time_rate15m / pg:ins:cpu_count or (0 * pg_up - 1)
pg:cls:load1pg:cls:active_time_rate1m / pg:cls:cpu_count or (0 * pg:cls:size - 1)
pg:cls:load5pg:cls:active_time_rate5m / pg:cls:cpu_count or (0 * pg:cls:size - 1)
pg:cls:load15pg:cls:active_time_rate15m / pg:cls:cpu_count or (0 * pg:cls:size - 1)
pg:db:ixact_ratio_1mpg:db:ixact_time_rate1m / (pg:db:active_time_rate1m + pg:db:ixact_time_rate1m)
pg:ins:ixact_ratio_1mpg:ins:ixact_time_rate1m / (pg:ins:active_time_rate1m + pg:ins:ixact_time_rate1m)
pg:cls:ixact_ratio_1mpg:cls:ixact_time_rate1m / (pg:cls:active_time_rate1m + pg:cls:ixact_time_rate1m)
pg:env:ixact_ratio_1mpg:env:ixact_time_rate1m / (pg:env:active_time_rate1m + pg:env:ixact_time_rate1m)
pg:db:ixact_ratio_5mpg:db:ixact_time_rate5m / (pg:db:active_time_rate5m + pg:db:ixact_time_rate5m)
pg:ins:ixact_ratio_5mpg:ins:ixact_time_rate5m / (pg:ins:active_time_rate5m + pg:ins:ixact_time_rate5m)
pg:cls:ixact_ratio_5mpg:cls:ixact_time_rate5m / (pg:cls:active_time_rate5m + pg:cls:ixact_time_rate5m)
pg:env:ixact_ratio_5mpg:env:ixact_time_rate5m / (pg:env:active_time_rate5m + pg:env:ixact_time_rate5m)
pg:db:ixact_ratio_15mpg:db:ixact_time_rate15m / (pg:db:active_time_rate15m + pg:db:ixact_time_rate15m)
pg:ins:ixact_ratio_15mpg:ins:ixact_time_rate15m / (pg:ins:active_time_rate15m + pg:ins:ixact_time_rate15m)
pg:cls:ixact_ratio_15mpg:cls:ixact_time_rate15m / (pg:cls:active_time_rate15m + pg:cls:ixact_time_rate15m)
pg:env:ixact_ratio_15mpg:env:ixact_time_rate15m / (pg:env:active_time_rate15m + pg:env:ixact_time_rate15m)
pg:db:num_backendspg_db_numbackends
pg:ins:num_backendssum without (datname) (pg:db:num_backends)
pg:cls:num_backendssum by (job, cls) (pg:ins:num_backends)
pg:db:active_backendssum without(state) (pg_activity_count{state="active"})
pg:ins:active_backendssum without(datname) (pg:db:active_backends)
pg:cls:active_backendssum by (job, cls) (pg:ins:active_backends)
pg:env:active_backendssum by (job) (pg:cls:active_backends)
pg:db:ixact_backendssum without(state) (pg_activity_count{state=~"idle in.*"})
pg:ins:ixact_backendssum without(datname) (pg:db:ixact_backends)
pg:cls:ixact_backendssum by (job, cls) (pg:ins:ixact_backends)
pg:env:ixact_backendssum by (job) (pg:cls:ixact_backends)
pg:ins:conn_limitpg_setting_max_connections
pg:db:conn_limit(pg_db_conn_limit != -1 ) or (0 * pg_db_conn_limit + on(cls, ins) group_left pg_setting_max_connections)
pg:ins:conn_usagepg:ins:num_backends / pg:ins:conn_limit
pg:db:conn_usagepg:db:num_backends / pg:db:conn_limit
pg:db:agepg_db_age / 2147483647
pg:ins:agemax without (datname) (pg:db:age{datname!~"template[0-9]"})
pg:cls:agemax by (job, cls) (pg:ins:age)
pg:env:agemax by (job) (pg:cls:age)
pg:db:age_deriv1hderiv(pg_db_age[1h])
pg:db:age_exhaust(2147483648 - pg_db_age) / pg:db:age_deriv1h
pg:db:tup_fetched_rate1mrate(pg_db_tup_fetched[1m])
pg:ins:tup_fetched_rate1msum without(datname) (pg:db:tup_fetched_rate1m)
pg:cls:tup_fetched_rate1msum by (job, cls) (pg:ins:tup_fetched_rate1m)
pg:env:tup_fetched_rate1msum by (job) (pg:cls:tup_fetched_rate1m)
pg:db:tup_returned_rate1mrate(pg_db_tup_returned[1m])
pg:ins:tup_returned_rate1msum without(datname) (pg:db:tup_returned_rate1m)
pg:cls:tup_returned_rate1msum by (job, cls) (pg:ins:tup_returned_rate1m)
pg:env:tup_returned_rate1msum by (job) (pg:cls:tup_returned_rate1m)
pg:db:tup_inserted_rate1mrate(pg_db_tup_inserted[1m])
pg:ins:tup_inserted_rate1msum without(datname) (pg:db:tup_inserted_rate1m)
pg:cls:tup_inserted_rate1msum by (job, cls) (pg:ins:tup_inserted_rate1m)
pg:env:tup_inserted_rate1msum by (job) (pg:cls:tup_inserted_rate1m)
pg:db:tup_updated_rate1mpg:db:tup_updated_rate1m
pg:ins:tup_updated_rate1msum without(datname) (pg:db:tup_updated_rate1m)
pg:cls:tup_updated_rate1msum by (job, cls) (pg:ins:tup_updated_rate1m)
pg:env:tup_updated_rate1msum by (job) (pg:cls:tup_updated_rate1m)
pg:db:tup_deleted_rate1mrate(pg_db_tup_deleted[1m])
pg:ins:tup_deleted_rate1msum without(datname) (pg:db:tup_deleted_rate1m)
pg:cls:tup_deleted_rate1msum by (job, cls) (pg:ins:tup_deleted_rate1m)
pg:env:tup_deleted_rate1msum by (job) (pg:cls:tup_deleted_rate1m)
pg:db:tup_modified_rate1mrate(pg_db_tup_modified[1m])
pg:ins:tup_modified_rate1msum without(datname) (pg:db:tup_modified_rate1m)
pg:cls:tup_modified_rate1msum by (job, cls) (pg:ins:tup_modified_rate1m)
pg:env:tup_modified_rate1msum by (job) (pg:cls:tup_modified_rate1m)
pg:db:temp_bytes_rate1mrate(pg_db_temp_bytes[1m])
pg:ins:temp_bytessum without (datname) (pg:db:temp_bytes)
pg:cls:temp_bytessum by (job, cls) (pg:ins:temp_bytes)
pg:db:temp_files_1mincrease(pg_db_temp_files[1m])
pg:ins:temp_files_1msum without(datname) (pg:db:temp_files)
pg:cls:temp_files_1msum by (job, cls) (pg:ins:temp_files)
pg:db:db_sizepg_size_bytes{datname!~"wal|log"}
pg:ins:db_sizesum without (datname) (pg:db:db_size)
pg:cls:db_sizesum by (job, cls) (pg:ins:db_size)
pg:ins:wal_sizesum without (datname) (pg_size_bytes{datname="wal"})
pg:cls:wal_sizesum by (job, cls) (pg:ins:wal_size)
pg:ins:log_sizesum without (datname) (pg_size_bytes{datname="log"})
pg:cls:log_sizesum by (job, cls) (pg:ins:log_size)
pg:ins:file_sizesum without(datname) (pg_size_bytes)
pg:cls:file_sizesum by (job, cls) (pg:ins:file_size)
pg:db:blks_read_1mincrease(pg_db_blks_read[1m])
pg:db:blks_hit_1mincrease(pg_db_blks_hit[1m])
pg:db:blks_access_1mincrease(pg_db_blks_access[1m])
pg:db:blks_hit_ratio1mpg:db:blks_hit_1m / pg:db:blks_access_1m
pg:ins:blks_hit_ratio1msum without (datname) (pg:db:blks_hit_1m) / sum without (datname) (pg:db:blks_access_1m)
pg:db:blk_read_time_seconds_rate1mrate(pg_db_blk_read_time[1m])
pg:db:blk_write_time_seconds_rate1mrate(pg_db_blk_write_time[1m])
pg:db:blk_io_time_seconds_rate1mpg:db:blk_read_time_seconds_rate1m + pg:db:blk_write_time_seconds_rate1m
pg:ins:buf_flush_checkpoint_rate1mrate(pg_checkpointer_buffers_written[1m]) or ignoring(__name__) rate(pg_bgwriter_buffers_checkpoint[1m])
pg:cls:buf_flush_checkpoint_rate1msum by (job, cls) (pg:ins:buf_flush_checkpoint_rate1m)
pg:ins:buf_flush_backend_rate1mrate(pg_bgwriter_buffers_backend[1m])
pg:cls:buf_flush_backend_rate1msum by (job, cls) (pg:ins:buf_flush_backend_rate1m)
pg:ins:buf_clean_rate1mrate(pg_bgwriter_buffers_clean[1m])
pg:cls:buf_clean_rate1msum by (job, cls) (pg:ins:buf_clean_rate1m)
pg:ins:buf_write_rate1mpg:ins:buf_flush_backend + pg:ins:buf_flush_checkpoint + pg:ins:buf_clean_rate1m
pg:cls:buf_write_rate1msum by (job, cls) (pg:ins:buf_flush_rate1m)
pg:ins:buf_alloc_rate1mrate(pg_bgwriter_buffers_alloc[1m])
pg:cls:buf_alloc_rate1msum by (job, cls) (pg:ins:buf_alloc_rate1m)
pg:ins:ckpt_timed_1mincrease(pg_checkpointer_timed[1m])
pg:ins:ckpt_req_1mincrease(pg_checkpointer_req[1m])
pg:ins:ckpt_1hincrease(pg_checkpointer_timed[1h]) + increase(pg_checkpointer_req[1h])
pg:ins:lsn_rate1mrate(pg_lsn[1m])
pg:cls:lsn_rate1msum by (job, cls) (pg:ins:lsn_rate1m * on(ins) group_left() (1 - pg_in_recovery))
pg:env:lsn_rate1msum by (job) (pg:cls:lsn_rate1m)
pg:table:scan_rate1mrate(pg_table_tbl_scan[1m])
pg:query:call_rate1mrate(pg_query_calls[1m])
pg:query:rt_1mrate(pg_query_exec_time[1m]) / pg:query:call_rate1m
PgBouncer: 169 recording rules
Recorded MetricExpression
pgbouncer:ins:poolssum without (list) (pgbouncer_list_items{list="pools"})
pgbouncer:ins:pool_databasessum without (list) (pgbouncer_list_items{list="databases"})
pgbouncer:ins:pool_userssum without (list) (pgbouncer_list_items{list="users"})
pgbouncer:ins:login_clientssum without (list) (pgbouncer_list_items{list="login_clients"})
pgbouncer:ins:free_clientssum without (list) (pgbouncer_list_items{list="free_clients"})
pgbouncer:ins:used_clientssum without (list) (pgbouncer_list_items{list="used_clients"})
pgbouncer:ins:free_serverssum without (list) (pgbouncer_list_items{list="free_servers"})
pgbouncer:db:pool_max_connpgbouncer_database_pool_size{datname!="pgbouncer"} + pgbouncer_database_reserve_pool{datname!="pgbouncer"}
pgbouncer:db:pool_sizepgbouncer_database_pool_size{datname!="pgbouncer"}
pgbouncer:db:pool_reserve_sizepgbouncer_database_reserve_pool{datname!="pgbouncer"}
pgbouncer:db:pool_current_connpgbouncer_database_current_connections{datname!="pgbouncer"}
pgbouncer:db:pool_pausedpgbouncer_database_paused{datname!="pgbouncer"}
pgbouncer:db:pool_disabledpgbouncer_database_disabled{datname!="pgbouncer"}
pgbouncer:db:conn_usagepgbouncer:db:pool_current_conn / pgbouncer:db:pool_size
pgbouncer:db:conn_usage_reservepgbouncer:db:pool_current_conn / pgbouncer:db:pool_max_conn
pgbouncer:pool:maxwaitpgbouncer_pool_maxwait{datname!="pgbouncer"} + pgbouncer_pool_maxwait_us{datname!="pgbouncer"} / 1000000
pgbouncer:db:maxwaitmax without(user, pool_mode) (pgbouncer:pool:maxwait)
pgbouncer:ins:maxwaitmax without(datname) (pgbouncer:db:maxwait)
pgbouncer:cls:maxwaitmax by (job, cls) (pgbouncer:ins:maxwait)
pgbouncer:env:maxwaitmax by (job) (pgbouncer:cls:maxwait)
pgbouncer:pool:active_serverspgbouncer_pool_active_servers{datname!="pgbouncer"}
pgbouncer:db:active_serverssum without(user, pool_mode) (pgbouncer:pool:active_servers)
pgbouncer:ins:active_serverssum without(datname) (pgbouncer:db:active_servers)
pgbouncer:cls:active_serverssum by (job, cls) (pgbouncer:ins:active_servers)
pgbouncer:env:active_serverssum by (job) (pgbouncer:cls:active_servers)
pgbouncer:pool:idle_serverspgbouncer_pool_idle_servers{datname!="pgbouncer"}
pgbouncer:db:idle_serversmax without(user, pool_mode) (pgbouncer:pool:idle_servers)
pgbouncer:ins:idle_serverssum without(datname) (pgbouncer:db:idle_servers)
pgbouncer:cls:idle_serverssum by (job, cls) (pgbouncer:ins:idle_servers)
pgbouncer:env:idle_serverssum by (job) (pgbouncer:cls:idle_servers)
pgbouncer:pool:used_serverspgbouncer_pool_used_servers{datname!="pgbouncer"}
pgbouncer:db:used_serversmax without(user, pool_mode) (pgbouncer:pool:used_servers)
pgbouncer:ins:used_serverssum without(datname) (pgbouncer:db:used_servers)
pgbouncer:cls:used_serverssum by (job, cls) (pgbouncer:ins:used_servers)
pgbouncer:env:used_serverssum by (job) (pgbouncer:cls:used_servers)
pgbouncer:pool:tested_serverspgbouncer_pool_tested_servers{datname!="pgbouncer"}
pgbouncer:db:tested_serversmax without(user, pool_mode) (pgbouncer:pool:tested_servers)
pgbouncer:ins:tested_serverssum without(datname) (pgbouncer:db:tested_servers)
pgbouncer:cls:tested_serverssum by (job, cls) (pgbouncer:ins:tested_servers)
pgbouncer:env:tested_serverssum by (job) (pgbouncer:cls:tested_servers)
pgbouncer:pool:login_serverspgbouncer_pool_login_servers{datname!="pgbouncer"}
pgbouncer:db:login_serversmax without(user, pool_mode) (pgbouncer:pool:login_servers)
pgbouncer:ins:login_serverssum without(datname) (pgbouncer:db:login_servers)
pgbouncer:cls:login_serverssum by (job, cls) (pgbouncer:ins:login_servers)
pgbouncer:env:login_serverssum by (job) (pgbouncer:cls:login_servers)
pgbouncer:pool:active_clientspgbouncer_pool_active_clients{datname!="pgbouncer"}
pgbouncer:db:active_clientsmax without(user, pool_mode) (pgbouncer:pool:active_clients)
pgbouncer:ins:active_clientssum without(datname) (pgbouncer:db:active_clients)
pgbouncer:cls:active_clientssum by (job, cls) (pgbouncer:ins:active_clients)
pgbouncer:env:active_clientssum by (job) (pgbouncer:cls:active_clients)
pgbouncer:pool:waiting_clientspgbouncer_pool_waiting_clients{datname!="pgbouncer"}
pgbouncer:db:waiting_clientsmax without(user, pool_mode) (pgbouncer:pool:waiting_clients)
pgbouncer:ins:waiting_clientssum without(datname) (pgbouncer:db:waiting_clients)
pgbouncer:cls:waiting_clientssum by (job, cls) (pgbouncer:ins:waiting_clients)
pgbouncer:env:waiting_clientssum by (job) (pgbouncer:cls:waiting_clients)
pgbouncer:db:tx_rate1mrate(pgbouncer_stat_total_sent{datname!="pgbouncer"}[1m])
pgbouncer:ins:tx_rate1msum without (datname) (pgbouncer:db:tx_rate1m)
pgbouncer:cls:tx_rate1msum by (job, cls) (pgbouncer:ins:tx_rate1m)
pgbouncer:env:tx_rate1msum by (job) (pgbouncer:cls:tx_rate1m)
pgbouncer:db:rx_rate1mrate(pgbouncer_stat_total_received{datname!="pgbouncer"}[1m])
pgbouncer:ins:rx_rate1msum without (datname) (pgbouncer:db:rx_rate1m)
pgbouncer:cls:rx_rate1msum by (job, cls) (pgbouncer:ins:rx_rate1m)
pgbouncer:env:rx_rate1msum by (job) (pgbouncer:cls:rx_rate1m)
pgbouncer:db:xact_rate1mrate(pgbouncer_stat_total_xact_count{datname!="pgbouncer"}[1m])
pgbouncer:ins:xact_rate1msum without(datname) (pgbouncer:db:xact_rate1m)
pgbouncer:cls:xact_rate1msum by (job, cls) (pgbouncer:ins:xact_rate1m)
pgbouncer:env:xact_rate1msum by (job) (pgbouncer:cls:xact_rate1m)
pgbouncer:db:xact_rate5mrate(pgbouncer_stat_total_xact_count{datname!="pgbouncer"}[5m])
pgbouncer:ins:xact_rate5msum without(datname) (pgbouncer:db:xact_rate5m)
pgbouncer:cls:xact_rate5msum by (job, cls) (pgbouncer:ins:xact_rate5m)
pgbouncer:env:xact_rate5msum by (job) (pgbouncer:cls:xact_rate5m)
pgbouncer:db:xact_rate15mrate(pgbouncer_stat_total_xact_count{datname!="pgbouncer"}[15m])
pgbouncer:ins:xact_rate15msum without(datname) (pgbouncer:db:xact_rate15m)
pgbouncer:cls:xact_rate15msum by (job, cls) (pgbouncer:ins:xact_rate15m)
pgbouncer:env:xact_rate15msum by (job) (pgbouncer:cls:xact_rate15m)
pgbouncer:db:xact_time_rate1mrate(pgbouncer_stat_total_xact_time{datname!="pgbouncer"}[1m])
pgbouncer:ins:xact_time_rate1msum without(datname) (pgbouncer:db:xact_time_rate1m)
pgbouncer:cls:xact_time_rate1msum by (job, cls) (pgbouncer:ins:xact_time_rate1m)
pgbouncer:env:xact_time_rate1msum by (job) (pgbouncer:cls:xact_time_rate1m)
pgbouncer:db:xact_time_rate5mrate(pgbouncer_stat_total_xact_time{datname!="pgbouncer"}[5m])
pgbouncer:ins:xact_time_rate5msum without(datname) (pgbouncer:db:xact_time_rate5m)
pgbouncer:cls:xact_time_rate5msum by (job, cls) (pgbouncer:ins:xact_time_rate5m)
pgbouncer:env:xact_time_rate5msum by (job) (pgbouncer:cls:xact_time_rate5m)
pgbouncer:db:xact_time_rate15mrate(pgbouncer_stat_total_xact_time{datname!="pgbouncer"}[15m])
pgbouncer:ins:xact_time_rate15msum without(datname) (pgbouncer:db:xact_time_rate15m)
pgbouncer:cls:xact_time_rate15msum by (job, cls) (pgbouncer:ins:xact_time_rate15m)
pgbouncer:env:xact_time_rate15msum by (job) (pgbouncer:cls:xact_time_rate15m)
pgbouncer:db:xact_rt_1mpgbouncer:db:xact_time_rate1m / pgbouncer:db:xact_rate1m
pgbouncer:ins:xact_rt_1mpgbouncer:ins:xact_time_rate1m / pgbouncer:ins:xact_rate1m
pgbouncer:cls:xact_rt_1mpgbouncer:cls:xact_time_rate1m / pgbouncer:cls:xact_rate1m
pgbouncer:env:xact_rt_1mpgbouncer:env:xact_time_rate1m / pgbouncer:env:xact_rate1m
pgbouncer:db:xact_rt_5mpgbouncer:db:xact_time_rate5m / pgbouncer:db:xact_rate5m
pgbouncer:ins:xact_rt_5mpgbouncer:ins:xact_time_rate5m / pgbouncer:ins:xact_rate5m
pgbouncer:cls:xact_rt_5mpgbouncer:cls:xact_time_rate5m / pgbouncer:cls:xact_rate5m
pgbouncer:env:xact_rt_5mpgbouncer:env:xact_time_rate5m / pgbouncer:env:xact_rate5m
pgbouncer:db:xact_rt_15mpgbouncer:db:xact_time_rate15m / pgbouncer:db:xact_rate15m
pgbouncer:ins:xact_rt_15mpgbouncer:ins:xact_time_rate15m / pgbouncer:ins:xact_rate15m
pgbouncer:cls:xact_rt_15mpgbouncer:cls:xact_time_rate15m / pgbouncer:cls:xact_rate15m
pgbouncer:env:xact_rt_15mpgbouncer:env:xact_time_rate15m / pgbouncer:env:xact_rate15m
pgbouncer:db:query_rate1mrate(pgbouncer_stat_total_query_count{datname!="pgbouncer"}[1m])
pgbouncer:ins:query_rate1msum without(datname) (pgbouncer:db:query_rate1m)
pgbouncer:cls:query_rate1msum by (job, cls) (pgbouncer:ins:query_rate1m)
pgbouncer:env:query_rate1msum by (job) (pgbouncer:cls:query_rate1m)
pgbouncer:db:query_rate5mrate(pgbouncer_stat_total_query_count{datname!="pgbouncer"}[5m])
pgbouncer:ins:query_rate5msum without(datname) (pgbouncer:db:query_rate5m)
pgbouncer:cls:query_rate5msum by (job, cls) (pgbouncer:ins:query_rate5m)
pgbouncer:env:query_rate5msum by (job) (pgbouncer:cls:query_rate5m)
pgbouncer:db:query_rate15mrate(pgbouncer_stat_total_query_count{datname!="pgbouncer"}[15m])
pgbouncer:ins:query_rate15msum without(datname) (pgbouncer:db:query_rate15m)
pgbouncer:cls:query_rate15msum by (job, cls) (pgbouncer:ins:query_rate15m)
pgbouncer:env:query_rate15msum by (job) (pgbouncer:cls:query_rate15m)
pgbouncer:db:query_time_rate1mrate(pgbouncer_stat_total_query_time{datname!="pgbouncer"}[1m])
pgbouncer:ins:query_time_rate1msum without(datname) (pgbouncer:db:query_time_rate1m)
pgbouncer:cls:query_time_rate1msum by (job, cls) (pgbouncer:ins:query_time_rate1m)
pgbouncer:env:query_time_rate1msum by (job) (pgbouncer:cls:query_time_rate1m)
pgbouncer:db:query_time_rate5mrate(pgbouncer_stat_total_query_time{datname!="pgbouncer"}[5m])
pgbouncer:ins:query_time_rate5msum without(datname) (pgbouncer:db:query_time_rate5m)
pgbouncer:cls:query_time_rate5msum by (job, cls) (pgbouncer:ins:query_time_rate5m)
pgbouncer:env:query_time_rate5msum by (job) (pgbouncer:cls:query_time_rate5m)
pgbouncer:db:query_time_rate15mrate(pgbouncer_stat_total_query_time{datname!="pgbouncer"}[15m])
pgbouncer:ins:query_time_rate15msum without(datname) (pgbouncer:db:query_time_rate15m)
pgbouncer:cls:query_time_rate15msum by (job, cls) (pgbouncer:ins:query_time_rate15m)
pgbouncer:env:query_time_rate15msum by (job) (pgbouncer:cls:query_time_rate15m)
pgbouncer:db:query_rt_1mpgbouncer:db:query_time_rate1m / pgbouncer:db:query_rate1m
pgbouncer:ins:query_rt_1mpgbouncer:ins:query_time_rate1m / pgbouncer:ins:query_rate1m
pgbouncer:cls:query_rt_1mpgbouncer:cls:query_time_rate1m / pgbouncer:cls:query_rate1m
pgbouncer:env:query_rt_1mpgbouncer:env:query_time_rate1m / pgbouncer:env:query_rate1m
pgbouncer:db:query_rt_5mpgbouncer:db:query_time_rate5m / pgbouncer:db:query_rate5m
pgbouncer:ins:query_rt_5mpgbouncer:ins:query_time_rate5m / pgbouncer:ins:query_rate5m
pgbouncer:cls:query_rt_5mpgbouncer:cls:query_time_rate5m / pgbouncer:cls:query_rate5m
pgbouncer:env:query_rt_5mpgbouncer:env:query_time_rate5m / pgbouncer:env:query_rate5m
pgbouncer:db:query_rt_15mpgbouncer:db:query_time_rate15m / pgbouncer:db:query_rate15m
pgbouncer:ins:query_rt_15mpgbouncer:ins:query_time_rate15m/ pgbouncer:ins:query_rate15m
pgbouncer:cls:query_rt_15mpgbouncer:cls:query_time_rate15m / pgbouncer:cls:query_rate15m
pgbouncer:env:query_rt_15mpgbouncer:env:query_time_rate15m / pgbouncer:env:query_rate15m
pgbouncer:db:xact_sigma15mstddev_over_time(pgbouncer:db:xact_rate1m[15m])
pgbouncer:ins:xact_sigma15mstddev_over_time(pgbouncer:ins:xact_rate1m[15m])
pgbouncer:cls:xact_sigma15mstddev_over_time(pgbouncer:cls:xact_rate1m[15m])
pgbouncer:env:xact_sigma15mstddev_over_time(pgbouncer:env:xact_rate1m[15m])
pgbouncer:db:xact_rt_sigma15mstddev_over_time(pgbouncer:db:xact_rt_1m[15m])
pgbouncer:ins:xact_rt_sigma15mstddev_over_time(pgbouncer:ins:xact_rt_1m[15m])
pgbouncer:cls:xact_rt_sigma15mstddev_over_time(pgbouncer:cls:xact_rt_1m[15m])
pgbouncer:env:xact_rt_sigma15mstddev_over_time(pgbouncer:env:xact_rt_1m[15m])
pgbouncer:db:query_sigma15mstddev_over_time(pgbouncer:db:query_rate1m[15m])
pgbouncer:ins:query_sigma15mstddev_over_time(pgbouncer:ins:query_rate1m[15m])
pgbouncer:cls:query_sigma15mstddev_over_time(pgbouncer:cls:query_rate1m[15m])
pgbouncer:env:query_sigma15mstddev_over_time(pgbouncer:env:query_rate1m[15m])
pgbouncer:db:query_rt_sigma15mstddev_over_time(pgbouncer:db:query_rt_1m[15m])
pgbouncer:ins:query_rt_sigma15mstddev_over_time(pgbouncer:ins:query_rt_1m[15m])
pgbouncer:cls:query_rt_sigma15mstddev_over_time(pgbouncer:cls:query_rt_1m[15m])
pgbouncer:env:query_rt_sigma15mstddev_over_time(pgbouncer:env:query_rt_1m[15m])
pgbouncer:ins:load1pgbouncer:ins:query_time_rate1m / on(ins) group_left pg:ins:cpu_count or (0 * pgbouncer_up - 1)
pgbouncer:ins:load5pgbouncer:ins:query_time_rate5m / on(ins) group_left pg:ins:cpu_count or (0 * pgbouncer_up - 1)
pgbouncer:ins:load15pgbouncer:ins:query_time_rate15m / on(ins) group_left pg:ins:cpu_count or (0 * pgbouncer_up - 1)
pgbouncer:cls:load1pgbouncer:cls:query_time_rate1m / pg:cls:cpu_count or (0 * pg:cls:size - 1)
pgbouncer:cls:load5pgbouncer:cls:query_time_rate5m / pg:cls:cpu_count or (0 * pg:cls:size - 1)
pgbouncer:cls:load15pgbouncer:cls:query_time_rate15m / pg:cls:cpu_count or (0 * pg:cls:size - 1)
pg:ins:saturation1max without (instance) (pg:ins:load1 > ignoring(instance) pgbouncer:ins:load1 or pgbouncer:ins:load1)
pg:ins:saturation5max without (instance) (pg:ins:load5 > ignoring(instance) pgbouncer:ins:load5 or pgbouncer:ins:load5)
pg:ins:saturation15max without (instance) (pg:ins:load15 > ignoring(instance) pgbouncer:ins:load15 or pgbouncer:ins:load15)
pg:cls:saturation1pg:cls:load1 > pgbouncer:cls:load1 or pgbouncer:cls:load1
pg:cls:saturation5pg:cls:load5 > pgbouncer:cls:load5 or pgbouncer:cls:load5
pg:cls:saturation15pg:cls:load15 > pgbouncer:cls:load15 or pgbouncer:cls:load15
ins:pressure1clamp_min(max without (instance) (pg:ins:cpu_usage_1m > pg:ins:saturation1 or pg:ins:saturation1), 0)
ins:pressure5clamp_min(max without (instance) (pg:ins:cpu_usage_5m > pg:ins:saturation5 or pg:ins:saturation5), 0)
ins:pressure15clamp_min(max without (instance) (pg:ins:cpu_usage_15m > pg:ins:saturation15 or pg:ins:saturation15), 0)
cls:pressure1clamp_min(max by (job, cls) (pg:cls:cpu_usage_1m > pg:cls:saturation1 or pg:cls:saturation1), 0)
cls:pressure5clamp_min(max by (job, cls) (pg:cls:cpu_usage_5m > pg:cls:saturation5 or pg:cls:saturation5), 0)
cls:pressure15clamp_min(max by (job, cls) (pg:cls:cpu_usage_15m > pg:cls:saturation15 or pg:cls:saturation15), 0)

Current SQL Collectors

The current pg_exporter.yml contains 84 collector configuration entries for PostgreSQL and optional extensions; the separate PgBouncer template has 12 entries. Entries sharing a metric namespace usually represent version or primary/replica variants, not 84 simultaneous collection tasks. Version bounds and tags are copied from the configuration. Activation also depends on exporter mode, skip, probe queries, installed extensions, and privileges.

Follow a collector link to inspect its SQL, output fields, types, and HELP text. Field counts include value fields such as GAUGE, COUNTER, and HISTOGRAM, but exclude LABEL / DISCARD. They include duplicate definitions across versions and cannot be summed into a raw-metric total.

Collector ConfigurationMetric NamespaceMinimum Version (Inclusive)Upper Version Bound (Exclusive)tagsValue Field Count
pg_primary_onlypg10—cluster, primary15
pg_replica_onlypg10—cluster, replica15
pg_meta_13pg_meta13—cluster1
pg_meta_10pg_meta9.613cluster1
pg_settingpg_setting10—cluster36
pg_repl_12pg_repl12—cluster20
pg_repl_10pg_repl1012cluster19
pg_sync_standbypg_sync_standby9.4—cluster1
pg_downstreampg_downstream9.4—cluster1
pg_slot_17pg_slot17—cluster26
pg_slot_16pg_slot1617cluster22
pg_slot_14pg_slot1416cluster, primary21
pg_slot_13pg_slot1314cluster, primary11
pg_slot_10pg_slot1013cluster, primary9
pg_recv_13pg_recv13—cluster, replica12
pg_recv_11pg_recv1113cluster, replica11
pg_recv_10pg_recv1011cluster, replica11
pg_sub_19pg_sub19—cluster21
pg_sub_16pg_sub1619cluster9
pg_sub_15pg_sub1516cluster9
pg_sub_10pg_sub1015cluster7
pg_originpg_origin9.5—cluster2
pg_io_18pg_io18—cluster17
pg_io_16pg_io1618cluster14
pg_sizepg_size10—cluster1
pg_archiverpg_archiver9.4—cluster5
pg_bgwriter_17pg_bgwriter17—cluster4
pg_bgwriter_10pg_bgwriter9.417cluster11
pg_checkpointer_18pg_checkpointer18—cluster11
pg_checkpointer_17pg_checkpointer1718cluster9
pg_checkpointer_10pg_checkpointer9.417cluster6
pg_sslpg_ssl9.5—cluster2
pg_checkpointpg_checkpoint10—cluster19
pg_timelinepg_timeline10—cluster1
pg_recoverypg_recovery9.6—cluster, replica5
pg_recovery_prefetchpg_recovery_prefetch15—cluster, replica10
pg_recovery_statepg_recovery_state19—cluster, replica9
pg_slru_13pg_slru13—cluster8
pg_shmempg_shmem13—cluster, schema:monitor3
pg_wal_19pg_wal19—cluster6
pg_wal_18pg_wal1819cluster5
pg_wal_14pg_wal1418cluster9
pg_activitypg_activity9.4—cluster4
pg_waitpg_wait9.6—cluster1
pg_backendpg_backend10—cluster1
pg_xactpg_xact9.4—cluster3
pg_xact_agepg_xact_age10—cluster2
pg_lockpg_lock9.4—cluster1
pg_lock_statpg_lock_stat19—cluster3
pg_query_17pg_query17—cluster, extension:pg_stat_statements9
pg_query_13pg_query1317cluster, extension:pg_stat_statements9
pg_query_10pg_query9.413cluster, extension:pg_stat_statements8
pg_vacuuming_18pg_vacuuming18—cluster, primary5
pg_vacuuming_17pg_vacuuming1718cluster, primary4
pg_vacuuming_12pg_vacuuming1217cluster, primary1
pg_indexingpg_indexing12—cluster, primary4
pg_clusteringpg_clustering12—cluster, primary2
pg_backuppg_backup13—cluster3
pg_db_18pg_db18—cluster37
pg_db_14pg_db1418cluster35
pg_db_12pg_db1214cluster28
pg_db_10pg_db9.212cluster26
pg_db_confl_16pg_db_confl16—cluster, replica6
pg_db_confl_15pg_db_confl9.116cluster, replica5
pg_pubrelpg_pubrel10——1
pg_subrelpg_subrel10——1
pg_vacuum_scorepg_vacuum_score19—primary11
pg_table_18pg_table18——35
pg_table_16pg_table1618—31
pg_table_13pg_table1316—30
pg_table_10pg_table9.413—29
pg_indexpg_index9.4——7
pg_funcpg_func9.4——3
pg_seqpg_seq10——3
pg_relkindpg_relkind9.4——1
pg_defpartpg_defpart11——1
pg_table_sizepg_table_size10——4
pg_table_bloatpg_table_bloat9.4——2
pg_index_bloatpg_index_bloat9.4——2
pg_wait_eventpg_wait_event10—cluster, extension:pg_wait_sampling1
pg_wait_event_1spg_wait_event_1s10—cluster, extension:pg_wait_sampling1
pg_tsdb_hypertablepg_tsdb_hypertable10—extension:timescaledb, schema:timescaledb_information4
pg_citus_nodepg_citus_node10—extension:citus6
pg_heartbeatpg_heartbeat9.1—dbname:postgres, schema:monitor3

Version ranges include the lower bound and exclude the upper bound; see the exporter version-matching logic. An em dash indicates no upper bound. predicate_queries first checks dependencies such as TimescaleDB, Citus, and monitoring helper views. PostgreSQL major version alone does not guarantee that every optional metric can be collected.

Was this page helpful?

Last Modified 2026-10-26 · docs: sync reviewed Chinese application and operations guidance (f9613ee7)