Report oldest xmin source when autovacuum cannot remove tuples

Autovacuum logging now tells which backend or mechanism kept OldestXmin
from advancing when dead tuples remain, improving diagnosis of bloating
and wraparound hazards. ProcArray now records an OldestXminSource for
each computed horizon, and VACUUM retrieves it through the new
GetOldestNonRemovableTransactionIdWithReason() helper. The log output
names active transactions (with pid), hot standby feedback, prepared
transactions, replication slots, or otherwise labels the cause as
"other".

Author: Shinya Kato <shinya11.kato@gmail.com>
Reviewed-by:
Discussion: https://postgr.es/m/

Author: shinyaaa

src/backend/access/heap/vacuumlazy.c

@@ -1047,6 +1047,43 @@ heap_vacuum_rel(Relation rel, const VacuumParams params,
 			appendStringInfo(&buf,
 							 _("removable cutoff: %u, which was %d XIDs old when operation ended\n"),
 							 vacrel->cutoffs.OldestXmin, diff);
+			/*
+			 * If there are dead tuples not yet removable, report what
+			 * determined the OldestXmin horizon to aid diagnostics.
+			 */
+			if (vacrel->recently_dead_tuples > 0)
+			{
+				int			pid = vacrel->cutoffs.oldest_xmin_info.backend_pid;
+				bool		include_pid = pid > 0;
+
+				switch (vacrel->cutoffs.oldest_xmin_info.source)
+				{
+					case OLDESTXMIN_SOURCE_ACTIVE_TRANSACTION:
+						msgfmt = include_pid ?
+							_("oldest xmin source: active transaction (pid=%d)\n") :
+							_("oldest xmin source: active transaction\n");
+						break;
+					case OLDESTXMIN_SOURCE_HOT_STANDBY_FEEDBACK:
+						msgfmt = include_pid ?
+							_("oldest xmin source: hot standby feedback (pid=%d)\n") :
+							_("oldest xmin source: hot standby feedback\n");
+						break;
+					case OLDESTXMIN_SOURCE_PREPARED_TRANSACTION:
+						msgfmt = _("oldest xmin source: prepared transaction\n");
+						break;
+					case OLDESTXMIN_SOURCE_REPLICATION_SLOT:
+						msgfmt = _("oldest xmin source: replication slot\n");
+						break;
+					default:
+						msgfmt = _("oldest xmin source: other\n");
+						break;
+				}
+
+				if (include_pid)
+					appendStringInfo(&buf, msgfmt, pid);
+				else
+					appendStringInfoString(&buf, msgfmt);
+			}
 			if (frozenxid_updated)
 			{
 				diff = (int32) (vacrel->NewRelfrozenXid -

src/backend/commands/vacuum.c

@@ -1133,7 +1133,9 @@ vacuum_get_cutoffs(Relation rel, const VacuumParams params,
 	 * that only one vacuum process can be working on a particular table at
 	 * any time, and that each vacuum is always an independent transaction.
 	 */
-	cutoffs->OldestXmin = GetOldestNonRemovableTransactionId(rel);
+	cutoffs->OldestXmin =
+		GetOldestNonRemovableTransactionIdWithReason(rel,
+													 &cutoffs->oldest_xmin_info);
 
 	Assert(TransactionIdIsNormal(cutoffs->OldestXmin));
 

src/backend/storage/ipc/procarray.c

@@ -241,6 +241,12 @@ typedef struct ComputeXidHorizonsResult
 	 * session's temporary tables.
 	 */
 	TransactionId temp_oldest_nonremovable;
+
+	/* Identify what forced each of the horizons above. */
+	OldestXminInfo shared_oldest_nonremovable_info;
+	OldestXminInfo catalog_oldest_nonremovable_info;
+	OldestXminInfo data_oldest_nonremovable_info;
+	OldestXminInfo temp_oldest_nonremovable_info;
 } ComputeXidHorizonsResult;
 
 /*
@@ -1622,6 +1628,46 @@ TransactionIdIsInProgress(TransactionId xid)
 	return false;
 }
 
+/*
+ * Store horizon provenance in *info if caller requested it.
+ *
+ * Callers pass NULL when they are not interested in tracking the source.
+ */
+static inline void
+OldestXminInfoSet(OldestXminInfo *info, OldestXminSource source,
+				  int backend_pid)
+{
+	if (info == NULL)
+		return;
+
+	info->source = source;
+	info->backend_pid = backend_pid;
+}
+
+/*
+ * Update a tracked OldestXmin horizon with a candidate xid and source.
+ *
+ * If the candidate is older than *target, adopt it and remember why.
+ */
+static inline void
+UpdateOldestXmin(TransactionId *target, OldestXminInfo *info,
+				 TransactionId candidate, OldestXminSource source,
+				 int backend_pid)
+{
+	TransactionId old;
+	TransactionId new_horizon;
+
+	if (!TransactionIdIsValid(candidate))
+		return;
+
+	old = *target;
+	new_horizon = TransactionIdOlder(old, candidate);
+	if (TransactionIdEquals(new_horizon, old))
+		return;
+
+	*target = new_horizon;
+	OldestXminInfoSet(info, source, backend_pid);
+}
 
 /*
  * Determine XID horizons.
@@ -1689,6 +1735,8 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 
 	/* inferred after ProcArrayLock is released */
 	h->catalog_oldest_nonremovable = InvalidTransactionId;
+	OldestXminInfoSet(&h->catalog_oldest_nonremovable_info,
+					  OLDESTXMIN_SOURCE_OTHER, 0);
 
 	LWLockAcquire(ProcArrayLock, LW_SHARED);
 
@@ -1710,6 +1758,10 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 		h->oldest_considered_running = initial;
 		h->shared_oldest_nonremovable = initial;
 		h->data_oldest_nonremovable = initial;
+		OldestXminInfoSet(&h->shared_oldest_nonremovable_info,
+						  OLDESTXMIN_SOURCE_OTHER, 0);
+		OldestXminInfoSet(&h->data_oldest_nonremovable_info,
+						  OLDESTXMIN_SOURCE_OTHER, 0);
 
 		/*
 		 * Only modifications made by this backend affect the horizon for
@@ -1724,9 +1776,17 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 		 * latestCompletedXid.
 		 */
 		if (TransactionIdIsValid(MyProc->xid))
+		{
 			h->temp_oldest_nonremovable = MyProc->xid;
+			OldestXminInfoSet(&h->temp_oldest_nonremovable_info,
+							  OLDESTXMIN_SOURCE_ACTIVE_TRANSACTION, MyProcPid);
+		}
 		else
+		{
 			h->temp_oldest_nonremovable = initial;
+			OldestXminInfoSet(&h->temp_oldest_nonremovable_info,
+							  OLDESTXMIN_SOURCE_OTHER, 0);
+		}
 	}
 
 	/*
@@ -1744,6 +1804,8 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 		int8		statusFlags = ProcGlobal->statusFlags[index];
 		TransactionId xid;
 		TransactionId xmin;
+		OldestXminSource candidate_source;
+		int			candidate_pid;
 
 		/* Fetch xid just once - see GetNewTransactionId */
 		xid = UINT32_ACCESS_ONCE(other_xids[index]);
@@ -1768,8 +1830,8 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 		 * backends are protected even without this check, it can't hurt to
 		 * include them here as well..
 		 */
-		h->oldest_considered_running =
-			TransactionIdOlder(h->oldest_considered_running, xmin);
+		UpdateOldestXmin(&h->oldest_considered_running, NULL, xmin,
+						 OLDESTXMIN_SOURCE_OTHER, 0);
 
 		/*
 		 * Skip over backends either vacuuming (which is ok with rows being
@@ -1780,8 +1842,17 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 			continue;
 
 		/* shared tables need to take backends in all databases into account */
-		h->shared_oldest_nonremovable =
-			TransactionIdOlder(h->shared_oldest_nonremovable, xmin);
+		candidate_pid = proc->pid;
+		if (proc->pid == 0)
+			candidate_source = OLDESTXMIN_SOURCE_PREPARED_TRANSACTION;
+		else if (statusFlags & PROC_AFFECTS_ALL_HORIZONS)
+			candidate_source = OLDESTXMIN_SOURCE_HOT_STANDBY_FEEDBACK;
+		else
+			candidate_source = OLDESTXMIN_SOURCE_ACTIVE_TRANSACTION;
+
+		UpdateOldestXmin(&h->shared_oldest_nonremovable,
+						 &h->shared_oldest_nonremovable_info,
+						 xmin, candidate_source, candidate_pid);
 
 		/*
 		 * Normally sessions in other databases are ignored for anything but
@@ -1807,8 +1878,9 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 			(statusFlags & PROC_AFFECTS_ALL_HORIZONS) ||
 			in_recovery)
 		{
-			h->data_oldest_nonremovable =
-				TransactionIdOlder(h->data_oldest_nonremovable, xmin);
+			UpdateOldestXmin(&h->data_oldest_nonremovable,
+							 &h->data_oldest_nonremovable_info,
+							 xmin, candidate_source, candidate_pid);
 		}
 	}
 
@@ -1827,12 +1899,14 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 
 	if (in_recovery)
 	{
-		h->oldest_considered_running =
-			TransactionIdOlder(h->oldest_considered_running, kaxmin);
-		h->shared_oldest_nonremovable =
-			TransactionIdOlder(h->shared_oldest_nonremovable, kaxmin);
-		h->data_oldest_nonremovable =
-			TransactionIdOlder(h->data_oldest_nonremovable, kaxmin);
+		UpdateOldestXmin(&h->oldest_considered_running, NULL,
+						 kaxmin, OLDESTXMIN_SOURCE_OTHER, 0);
+		UpdateOldestXmin(&h->shared_oldest_nonremovable,
+						 &h->shared_oldest_nonremovable_info,
+						 kaxmin, OLDESTXMIN_SOURCE_OTHER, 0);
+		UpdateOldestXmin(&h->data_oldest_nonremovable,
+						 &h->data_oldest_nonremovable_info,
+						 kaxmin, OLDESTXMIN_SOURCE_OTHER, 0);
 		/* temp relations cannot be accessed in recovery */
 	}
 
@@ -1844,10 +1918,12 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 	/*
 	 * Check whether there are replication slots requiring an older xmin.
 	 */
-	h->shared_oldest_nonremovable =
-		TransactionIdOlder(h->shared_oldest_nonremovable, h->slot_xmin);
-	h->data_oldest_nonremovable =
-		TransactionIdOlder(h->data_oldest_nonremovable, h->slot_xmin);
+	UpdateOldestXmin(&h->shared_oldest_nonremovable,
+					 &h->shared_oldest_nonremovable_info,
+					 h->slot_xmin, OLDESTXMIN_SOURCE_REPLICATION_SLOT, 0);
+	UpdateOldestXmin(&h->data_oldest_nonremovable,
+					 &h->data_oldest_nonremovable_info,
+					 h->slot_xmin, OLDESTXMIN_SOURCE_REPLICATION_SLOT, 0);
 
 	/*
 	 * The only difference between catalog / data horizons is that the slot's
@@ -1857,13 +1933,16 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
 	 * that also can contain catalogs.
 	 */
 	h->shared_oldest_nonremovable_raw = h->shared_oldest_nonremovable;
-	h->shared_oldest_nonremovable =
-		TransactionIdOlder(h->shared_oldest_nonremovable,
-						   h->slot_catalog_xmin);
+	UpdateOldestXmin(&h->shared_oldest_nonremovable,
+					 &h->shared_oldest_nonremovable_info,
+					 h->slot_catalog_xmin,
+					 OLDESTXMIN_SOURCE_REPLICATION_SLOT, 0);
 	h->catalog_oldest_nonremovable = h->data_oldest_nonremovable;
-	h->catalog_oldest_nonremovable =
-		TransactionIdOlder(h->catalog_oldest_nonremovable,
-						   h->slot_catalog_xmin);
+	h->catalog_oldest_nonremovable_info = h->data_oldest_nonremovable_info;
+	UpdateOldestXmin(&h->catalog_oldest_nonremovable,
+					 &h->catalog_oldest_nonremovable_info,
+					 h->slot_catalog_xmin,
+					 OLDESTXMIN_SOURCE_REPLICATION_SLOT, 0);
 
 	/*
 	 * It's possible that slots backed up the horizons further than
@@ -1951,25 +2030,53 @@ GlobalVisHorizonKindForRel(Relation rel)
  */
 TransactionId
 GetOldestNonRemovableTransactionId(Relation rel)
+{
+	/* Delegate to the WithReason variant to avoid duplicated logic */
+	return GetOldestNonRemovableTransactionIdWithReason(rel, NULL);
+}
+
+/*
+ * Return horizon like GetOldestNonRemovableTransactionId(), and also classify
+ * the reason that determined that horizon at the time of computation.
+ */
+TransactionId
+GetOldestNonRemovableTransactionIdWithReason(Relation rel,
+											 OldestXminInfo *out_info)
 {
 	ComputeXidHorizonsResult horizons;
+	TransactionId target = InvalidTransactionId;
+	GlobalVisHorizonKind kind;
+	const OldestXminInfo *source_info = NULL;
+
+	if (out_info != NULL)
+		OldestXminInfoSet(out_info, OLDESTXMIN_SOURCE_OTHER, 0);
 
 	ComputeXidHorizons(&horizons);
 
-	switch (GlobalVisHorizonKindForRel(rel))
+	kind = GlobalVisHorizonKindForRel(rel);
+	switch (kind)
 	{
 		case VISHORIZON_SHARED:
-			return horizons.shared_oldest_nonremovable;
+			target = horizons.shared_oldest_nonremovable;
+			source_info = &horizons.shared_oldest_nonremovable_info;
+			break;
 		case VISHORIZON_CATALOG:
-			return horizons.catalog_oldest_nonremovable;
+			target = horizons.catalog_oldest_nonremovable;
+			source_info = &horizons.catalog_oldest_nonremovable_info;
+			break;
 		case VISHORIZON_DATA:
-			return horizons.data_oldest_nonremovable;
+			target = horizons.data_oldest_nonremovable;
+			source_info = &horizons.data_oldest_nonremovable_info;
+			break;
 		case VISHORIZON_TEMP:
-			return horizons.temp_oldest_nonremovable;
+			target = horizons.temp_oldest_nonremovable;
+			source_info = &horizons.temp_oldest_nonremovable_info;
+			break;
 	}
 
-	/* just to prevent compiler warnings */
-	return InvalidTransactionId;
+	if (out_info != NULL && TransactionIdIsValid(target) && source_info != NULL)
+		*out_info = *source_info;
+	return target;
 }
 
 /*

src/include/commands/vacuum.h

@@ -24,6 +24,7 @@
 #include "parser/parse_node.h"
 #include "storage/buf.h"
 #include "storage/lock.h"
+#include "storage/procarray.h"
 #include "utils/relcache.h"
 
 /*
@@ -288,6 +289,9 @@ struct VacuumCutoffs
 	 */
 	TransactionId FreezeLimit;
 	MultiXactId MultiXactCutoff;
+
+	/* What decided OldestXmin at acquisition time */
+	OldestXminInfo oldest_xmin_info;
 };
 
 /*

src/include/storage/procarray.h

@@ -20,6 +20,25 @@
 #include "utils/snapshot.h"
 
 
+/*
+ * Identifies what determined a relation's OldestXmin horizon.
+ * Used by autovacuum to report why dead tuples were not removable.
+ */
+typedef enum OldestXminSource
+{
+	OLDESTXMIN_SOURCE_ACTIVE_TRANSACTION,
+	OLDESTXMIN_SOURCE_HOT_STANDBY_FEEDBACK,
+	OLDESTXMIN_SOURCE_PREPARED_TRANSACTION,
+	OLDESTXMIN_SOURCE_REPLICATION_SLOT,
+	OLDESTXMIN_SOURCE_OTHER
+} OldestXminSource;
+
+typedef struct OldestXminInfo
+{
+	OldestXminSource source;
+	int			backend_pid;
+} OldestXminInfo;
+
 extern Size ProcArrayShmemSize(void);
 extern void ProcArrayShmemInit(void);
 extern void ProcArrayAdd(PGPROC *proc);
@@ -54,6 +73,8 @@ extern RunningTransactions GetRunningTransactionData(void);
 
 extern bool TransactionIdIsInProgress(TransactionId xid);
 extern TransactionId GetOldestNonRemovableTransactionId(Relation rel);
+extern TransactionId GetOldestNonRemovableTransactionIdWithReason(Relation rel,
+																  OldestXminInfo *info);
 extern TransactionId GetOldestTransactionIdConsideredRunning(void);
 extern TransactionId GetOldestActiveTransactionId(bool inCommitOnly,
 												  bool allDbs);

src/test/modules/test_misc/meson.build

@@ -18,6 +18,7 @@ tests += {
       't/007_catcache_inval.pl',
       't/008_replslot_single_user.pl',
       't/009_log_temp_files.pl',
+      't/010_autovacuum_oldest_xmin_reason.pl',
     ],
   },
 }