From 727d1df40a9cc38ebb5cb525e4dfa714799ae6e0 Mon Sep 17 00:00:00 2001 From: Shlok Kyal Date: Wed, 26 Nov 2025 08:52:29 +0530 Subject: [PATCH v12] Add slotsync_skip_reason to pg_replication_slots This patch introduces a new column slotsync_skip_reason to pg_replication_slots view. This indicates the reason for last slot synchronization skip. --- doc/src/sgml/monitoring.sgml | 4 +- doc/src/sgml/system-views.sgml | 49 +++++++++++++++++++ src/backend/catalog/system_views.sql | 3 +- src/backend/replication/logical/slotsync.c | 43 ++++++++++++++-- src/backend/replication/slot.c | 1 + src/backend/replication/slotfuncs.c | 28 ++++++++++- src/include/catalog/pg_proc.dat | 6 +-- src/include/replication/slot.h | 26 ++++++++++ .../t/040_standby_failover_slots_sync.pl | 6 +++ src/test/regress/expected/rules.out | 5 +- src/tools/pgindent/typedefs.list | 1 + 11 files changed, 158 insertions(+), 14 deletions(-) diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index dcc8474a7f7..e0556b6baac 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -1665,7 +1665,7 @@ description | Waiting for a newly initialized WAL file to reach durable storage Number of times the slot synchronization is skipped. Slot - synchronization occur only on standby servers and thus this column has + synchronization occurs only on standby servers and thus this column has no meaning on the primary server. @@ -1677,7 +1677,7 @@ description | Waiting for a newly initialized WAL file to reach durable storage Time at which last slot synchronization was skipped. Slot - synchronization occur only on standby servers and thus this column has + synchronization occurs only on standby servers and thus this column has no meaning on the primary server. diff --git a/doc/src/sgml/system-views.sgml b/doc/src/sgml/system-views.sgml index 0e623e7fb86..4dd5174ba1e 100644 --- a/doc/src/sgml/system-views.sgml +++ b/doc/src/sgml/system-views.sgml @@ -3102,6 +3102,55 @@ SELECT * FROM pg_locks pl LEFT JOIN pg_prepared_xacts ppx + + + slotsync_skip_reasontext + + + The reason for the last slot synchronization skip. This field is set only + for logical slots that are being synchronized from a primary server (that + is, those whose synced field is + true). The value of this column has no meaning on the + primary server; it defaults to none for all slots, but + may (if leftover from a promoted standby) also have a value other than + none. Possible values are: + + + + none means that the last slot synchronization + completed successfully. + + + + + remote_behind means that the last slot + synchronization was skipped because the slot is ahead of the + corresponding failover slot on the primary. + + + + + wal_not_flushed means that the last slot + synchronization was skipped because the standby had not flushed the + WAL corresponding to the confirmed flush position on the remote slot. + + + + + no_consistent_snapshot means that the last slot + synchronization was skipped because the standby could not build a + consistent snapshot. + + + + + slot_invalidated means that the last slot + synchronization was skipped because the slot is invalidated. + + + + + diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql index 6fffdb9398e..086c4c8fb6f 100644 --- a/src/backend/catalog/system_views.sql +++ b/src/backend/catalog/system_views.sql @@ -1060,7 +1060,8 @@ CREATE VIEW pg_replication_slots AS L.conflicting, L.invalidation_reason, L.failover, - L.synced + L.synced, + L.slotsync_skip_reason FROM pg_get_replication_slots() AS L LEFT JOIN pg_database D ON (L.datoid = D.oid); diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c index 1f4f06d467b..818f432172c 100644 --- a/src/backend/replication/logical/slotsync.c +++ b/src/backend/replication/logical/slotsync.c @@ -148,6 +148,35 @@ typedef struct RemoteSlot static void slotsync_failure_callback(int code, Datum arg); static void update_synced_slots_inactive_since(void); +/* + * Update slot sync skip stats. This function requires the caller to acquire + * the slot. + */ +static void +update_slotsync_skip_stats(SlotSyncSkipReason skip_reason) +{ + ReplicationSlot *slot; + + Assert(MyReplicationSlot); + + slot = MyReplicationSlot; + + /* + * Update the slot sync related stats in pg_stat_replication_slot when a + * slot sync is skipped + */ + if (skip_reason != SS_SKIP_NONE) + pgstat_report_replslotsync(slot); + + /* Update the slot sync skip reason */ + if (slot->slotsync_skip_reason != skip_reason) + { + SpinLockAcquire(&slot->mutex); + slot->slotsync_skip_reason = skip_reason; + SpinLockRelease(&slot->mutex); + } +} + /* * If necessary, update the local synced slot's metadata based on the data * from the remote slot. @@ -170,6 +199,7 @@ update_local_synced_slot(RemoteSlot *remote_slot, Oid remote_dbid, ReplicationSlot *slot = MyReplicationSlot; bool updated_xmin_or_lsn = false; bool updated_config = false; + SlotSyncSkipReason skip_reason = SS_SKIP_NONE; Assert(slot->data.invalidated == RS_INVAL_NONE); @@ -188,7 +218,7 @@ update_local_synced_slot(RemoteSlot *remote_slot, Oid remote_dbid, slot->data.catalog_xmin)) { /* Update slot sync skip stats */ - pgstat_report_replslotsync(slot); + update_slotsync_skip_stats(SS_SKIP_REMOTE_BEHIND); /* * This can happen in following situations: @@ -286,12 +316,15 @@ update_local_synced_slot(RemoteSlot *remote_slot, Oid remote_dbid, * persisted. See update_and_persist_local_synced_slot(). */ if (found_consistent_snapshot && !(*found_consistent_snapshot)) - pgstat_report_replslotsync(slot); + skip_reason = SS_SKIP_NO_CONSISTENT_SNAPSHOT; } updated_xmin_or_lsn = true; } + /* Update slot sync skip stats */ + update_slotsync_skip_stats(skip_reason); + if (remote_dbid != slot->data.database || remote_slot->two_phase != slot->data.two_phase || remote_slot->failover != slot->data.failover || @@ -696,7 +729,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid) /* Skip the sync of an invalidated slot */ if (slot->data.invalidated != RS_INVAL_NONE) { - pgstat_report_replslotsync(slot); + update_slotsync_skip_stats(SS_SKIP_INVALID); ReplicationSlotRelease(); return slot_updated; @@ -711,7 +744,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid) */ if (remote_slot->confirmed_lsn > latestFlushPtr) { - pgstat_report_replslotsync(slot); + update_slotsync_skip_stats(SS_SKIP_WAL_NOT_FLUSHED); /* * Can get here only if GUC 'synchronized_standby_slots' on the @@ -812,7 +845,7 @@ synchronize_one_slot(RemoteSlot *remote_slot, Oid remote_dbid) */ if (remote_slot->confirmed_lsn > latestFlushPtr) { - pgstat_report_replslotsync(slot); + update_slotsync_skip_stats(SS_SKIP_WAL_NOT_FLUSHED); /* * Can get here only if GUC 'synchronized_standby_slots' on the diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c index 1ec1e997b27..86ae99a3ca9 100644 --- a/src/backend/replication/slot.c +++ b/src/backend/replication/slot.c @@ -491,6 +491,7 @@ ReplicationSlotCreate(const char *name, bool db_specific, slot->last_saved_confirmed_flush = InvalidXLogRecPtr; slot->last_saved_restart_lsn = InvalidXLogRecPtr; slot->inactive_since = 0; + slot->slotsync_skip_reason = SS_SKIP_NONE; /* * Create the slot on disk. We haven't actually marked the slot allocated diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c index 0478fc9c977..7200c7f071d 100644 --- a/src/backend/replication/slotfuncs.c +++ b/src/backend/replication/slotfuncs.c @@ -228,6 +228,30 @@ pg_drop_replication_slot(PG_FUNCTION_ARGS) PG_RETURN_VOID(); } +/* + * Map a SlotSyncSkipReason enum to a human-readable string + */ +static char * +GetSlotSyncSkipReason(SlotSyncSkipReason reason) +{ + switch (reason) + { + case SS_SKIP_NONE: + return "none"; + case SS_SKIP_REMOTE_BEHIND: + return "remote_behind"; + case SS_SKIP_WAL_NOT_FLUSHED: + return "wal_not_flushed"; + case SS_SKIP_NO_CONSISTENT_SNAPSHOT: + return "no_consistent_snapshot"; + case SS_SKIP_INVALID: + return "slot_invalidated"; + } + + Assert(false); + return "none"; +} + /* * pg_get_replication_slots - SQL SRF showing all replication slots * that currently exist on the database cluster. @@ -235,7 +259,7 @@ pg_drop_replication_slot(PG_FUNCTION_ARGS) Datum pg_get_replication_slots(PG_FUNCTION_ARGS) { -#define PG_GET_REPLICATION_SLOTS_COLS 20 +#define PG_GET_REPLICATION_SLOTS_COLS 21 ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; XLogRecPtr currlsn; int slotno; @@ -443,6 +467,8 @@ pg_get_replication_slots(PG_FUNCTION_ARGS) values[i++] = BoolGetDatum(slot_contents.data.synced); + values[i++] = CStringGetTextDatum(GetSlotSyncSkipReason(slot_contents.slotsync_skip_reason)); + Assert(i == PG_GET_REPLICATION_SLOTS_COLS); tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat index 66431940700..66af2d96d67 100644 --- a/src/include/catalog/pg_proc.dat +++ b/src/include/catalog/pg_proc.dat @@ -11519,9 +11519,9 @@ proname => 'pg_get_replication_slots', prorows => '10', proisstrict => 'f', proretset => 't', provolatile => 's', prorettype => 'record', proargtypes => '', - proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,int8,bool,pg_lsn,timestamptz,bool,text,bool,bool}', - proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}', - proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,safe_wal_size,two_phase,two_phase_at,inactive_since,conflicting,invalidation_reason,failover,synced}', + proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,int8,bool,pg_lsn,timestamptz,bool,text,bool,bool,text}', + proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}', + proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,safe_wal_size,two_phase,two_phase_at,inactive_since,conflicting,invalidation_reason,failover,synced,slotsync_skip_reason}', prosrc => 'pg_get_replication_slots' }, { oid => '3786', descr => 'set up a logical replication slot', proname => 'pg_create_logical_replication_slot', provolatile => 'v', diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h index 09c69f83d57..054e81b6c43 100644 --- a/src/include/replication/slot.h +++ b/src/include/replication/slot.h @@ -71,6 +71,22 @@ typedef enum ReplicationSlotInvalidationCause /* Maximum number of invalidation causes */ #define RS_INVAL_MAX_CAUSES 4 +/* + * When slot sync worker is running or pg_sync_replication_slots is run, the + * slot sync can be skipped. This enum keeps a list of reasons of slot sync + * skip. + */ +typedef enum SlotSyncSkipReason +{ + SS_SKIP_NONE, /* No skip */ + SS_SKIP_WAL_NOT_FLUSHED, /* Standby did not flush the wal corresponding + * to confirmed flush of remote slot */ + SS_SKIP_REMOTE_BEHIND, /* Remote slot is behind the local slot */ + SS_SKIP_NO_CONSISTENT_SNAPSHOT, /* Standby could not build a consistent + * snapshot */ + SS_SKIP_INVALID /* Local slot is invalid */ +} SlotSyncSkipReason; + /* * On-Disk data of a replication slot, preserved across restarts. */ @@ -249,6 +265,16 @@ typedef struct ReplicationSlot */ XLogRecPtr last_saved_restart_lsn; + /* + * The reason for last slot sync skip. + * + * A slotsync skip typically occurs only for temporary slots. For + * persistent slots it is extremely rare (e.g., cases like + * SS_SKIP_WAL_NOT_FLUSHED or SS_SKIP_REMOTE_BEHIND). Also, temporary + * slots are dropped after server restart, so there is no value in + * persisting the slotsync_skip_reason. + */ + SlotSyncSkipReason slotsync_skip_reason; } ReplicationSlot; #define SlotIsPhysical(slot) ((slot)->data.database == InvalidOid) diff --git a/src/test/recovery/t/040_standby_failover_slots_sync.pl b/src/test/recovery/t/040_standby_failover_slots_sync.pl index 7d3c82e0a29..da1c3aee65d 100644 --- a/src/test/recovery/t/040_standby_failover_slots_sync.pl +++ b/src/test/recovery/t/040_standby_failover_slots_sync.pl @@ -1049,6 +1049,12 @@ $standby2->wait_for_log(qr/slot sync worker started/, $log_offset); $standby2->wait_for_log( qr/could not synchronize replication slot \"lsub1_slot\"/, $log_offset); +# Confirm that the slotsync skip reason is updated +$result = $standby2->safe_psql('postgres', + "SELECT slotsync_skip_reason FROM pg_replication_slots WHERE slot_name = 'lsub1_slot'" +); +is($result, 'remote_behind', "check slot sync skip reason"); + # Confirm that the slotsync skip statistics is updated $result = $standby2->safe_psql('postgres', "SELECT slotsync_skip_count > 0 FROM pg_stat_replication_slots WHERE slot_name = 'lsub1_slot'" diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out index c337f0bc30d..94e45dd4d57 100644 --- a/src/test/regress/expected/rules.out +++ b/src/test/regress/expected/rules.out @@ -1507,8 +1507,9 @@ pg_replication_slots| SELECT l.slot_name, l.conflicting, l.invalidation_reason, l.failover, - l.synced - FROM (pg_get_replication_slots() l(slot_name, plugin, slot_type, datoid, temporary, active, active_pid, xmin, catalog_xmin, restart_lsn, confirmed_flush_lsn, wal_status, safe_wal_size, two_phase, two_phase_at, inactive_since, conflicting, invalidation_reason, failover, synced) + l.synced, + l.slotsync_skip_reason + FROM (pg_get_replication_slots() l(slot_name, plugin, slot_type, datoid, temporary, active, active_pid, xmin, catalog_xmin, restart_lsn, confirmed_flush_lsn, wal_status, safe_wal_size, two_phase, two_phase_at, inactive_since, conflicting, invalidation_reason, failover, synced, slotsync_skip_reason) LEFT JOIN pg_database d ON ((l.datoid = d.oid))); pg_roles| SELECT pg_authid.rolname, pg_authid.rolsuper, diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index dfcd619bfee..c7e52cc2191 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2807,6 +2807,7 @@ SlabSlot SlotInvalidationCauseMap SlotNumber SlotSyncCtxStruct +SlotSyncSkipReason SlruCtl SlruCtlData SlruErrorCause -- 2.34.1