Measuring replay lag

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index adab2f8..fb39f4c 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -3256,6 +3256,26 @@ include_dir 'conf.d'
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-relay-lag-sample-interval" xreflabel="replay_lag_sample_interval">
+      <term><varname>replay_lag_sample_interval</varname> (<type>integer</type>)
+      <indexterm>
+       <primary><varname>replay_lag_sample_interval</> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls how often a standby should sample replay lag information to
+        send back to the primary or upstream standby while replaying WAL.  The
+        default is 1 second.  Units are milliseconds if not specified.  A
+        value of -1 disables the reporting of replay lag.  Estimated replay lag
+        can be seen in the <link linkend="monitoring-stats-views-table">
+        <literal>pg_stat_replication</></link> view of the upstream server.
+        This parameter can only be set
+        in the <filename>postgresql.conf</> file or on the server command line.
+       </para>
+      </listitem>
+     </varlistentry>
+
      <varlistentry id="guc-hot-standby-feedback" xreflabel="hot_standby_feedback">
       <term><varname>hot_standby_feedback</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 3de489e..a4cb0e4 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1381,6 +1381,12 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be replayed on this
+      standby server</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 6cec027..5bcb54b 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -82,6 +82,8 @@ extern uint32 bootstrap_data_checksum_version;
 #define PROMOTE_SIGNAL_FILE		"promote"
 #define FALLBACK_PROMOTE_SIGNAL_FILE "fallback_promote"
 
+/* Size of the circular buffer of timestamped LSNs. */
+#define XLOG_TIMESTAMP_BUFFER_SIZE 8192
 
 /* User-settable parameters */
 int			max_wal_size = 64;	/* 1 GB */
@@ -521,6 +523,26 @@ typedef struct XLogCtlInsert
 } XLogCtlInsert;
 
 /*
+ * A sample associating a timestamp with a given xlog position.
+ */
+typedef struct XLogTimestamp
+{
+	TimestampTz	timestamp;
+	XLogRecPtr	lsn;
+} XLogTimestamp;
+
+/*
+ * A circular buffer of LSNs and associated timestamps.  The buffer is empty
+ * when read_head == write_head.
+ */
+typedef struct XLogTimestampBuffer
+{
+	uint32			read_head;
+	uint32			write_head;
+	XLogTimestamp	buffer[XLOG_TIMESTAMP_BUFFER_SIZE];
+} XLogTimestampBuffer;
+
+/*
  * Total shared-memory state for XLOG.
  */
 typedef struct XLogCtlData
@@ -638,6 +660,12 @@ typedef struct XLogCtlData
 	/* timestamp of last COMMIT/ABORT record replayed (or being replayed) */
 	TimestampTz recoveryLastXTime;
 
+	/* timestamp from the most recently applied record associated with a timestamp. */
+	TimestampTz lastReplayedTimestamp;
+
+	/* a buffer of upstream timestamps for WAL that is not yet applied. */
+	XLogTimestampBuffer timestamps;
+
 	/*
 	 * timestamp of when we started replaying the current chunk of WAL data,
 	 * only relevant for replication or archive recovery
@@ -5981,6 +6009,44 @@ CheckRequiredParameterValues(void)
 }
 
 /*
+ * Called by the startup process after it has replayed up to 'lsn'.  Checks
+ * for timestamps associated with WAL positions that have now been replayed.
+ * If any are found, the latest such timestamp found is written to
+ * '*timestamp'.  Returns the new buffer read head position, which the caller
+ * should write into XLogCtl->timestamps.read_head while holding info_lck.
+ */
+static uint32
+CheckForReplayedTimestamps(XLogRecPtr lsn, TimestampTz *timestamp)
+{
+	uint32 read_head;
+
+	/*
+	 * It's OK to access timestamps.read_head without any kind synchronization
+	 * because this process is the only one to write to it.
+	 */
+	Assert(AmStartupProcess());
+	read_head = XLogCtl->timestamps.read_head;
+
+	/*
+	 * It's OK to access write_head without interlocking because it's an
+	 * aligned 32 bit value which we can read atomically on all supported
+	 * platforms to get some recent value, not a torn/garbage value.
+	 * Furthermore we must see a value that is at least as recent as any WAL
+	 * that we have replayed, because walreceiver calls
+	 * SetXLogReplayTimestampAtLsn before passing the corresponding WAL data
+	 * to the recovery process.
+	 */
+	while (read_head != XLogCtl->timestamps.write_head &&
+		   XLogCtl->timestamps.buffer[read_head].lsn <= lsn)
+	{
+		*timestamp = XLogCtl->timestamps.buffer[read_head].timestamp;
+		read_head = (read_head + 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+	}
+
+	return read_head;
+}
+
+/*
  * This must be called ONCE during postmaster or standalone-backend startup
  */
 void
@@ -6799,6 +6865,8 @@ StartupXLOG(void)
 			do
 			{
 				bool		switchedTLI = false;
+				TimestampTz	replayed_timestamp = 0;
+				uint32		timestamp_read_head;
 
 #ifdef WAL_DEBUG
 				if (XLOG_DEBUG ||
@@ -6952,24 +7020,34 @@ StartupXLOG(void)
 				/* Pop the error context stack */
 				error_context_stack = errcallback.previous;
 
+				/* Check if we have replayed a timestamped WAL position */
+				timestamp_read_head =
+					CheckForReplayedTimestamps(EndRecPtr, &replayed_timestamp);
+
 				/*
-				 * Update lastReplayedEndRecPtr after this record has been
-				 * successfully replayed.
+				 * Update lastReplayedEndRecPtr and lastReplayedTimestamp
+				 * after this record has been successfully replayed.
 				 */
 				SpinLockAcquire(&XLogCtl->info_lck);
 				XLogCtl->lastReplayedEndRecPtr = EndRecPtr;
 				XLogCtl->lastReplayedTLI = ThisTimeLineID;
+				XLogCtl->timestamps.read_head = timestamp_read_head;
+				if (replayed_timestamp != 0)
+					XLogCtl->lastReplayedTimestamp = replayed_timestamp;
 				SpinLockRelease(&XLogCtl->info_lck);
 
 				/*
 				 * If rm_redo called XLogRequestWalReceiverReply, then we wake
 				 * up the receiver so that it notices the updated
-				 * lastReplayedEndRecPtr and sends a reply to the master.
+				 * lastReplayedEndRecPtr and sends a reply to the master.  We
+				 * also wake it if we have replayed a WAL position that has
+				 * an associated timestamp so that the upstream server can
+				 * measure our replay lag.
 				 */
-				if (doRequestWalReceiverReply)
+				if (doRequestWalReceiverReply || replayed_timestamp != 0)
 				{
 					doRequestWalReceiverReply = false;
-					WalRcvForceReply();
+					WalRcvForceReply(replayed_timestamp != 0);
 				}
 
 				/* Remember this record as the last-applied one */
@@ -11750,3 +11828,81 @@ XLogRequestWalReceiverReply(void)
 {
 	doRequestWalReceiverReply = true;
 }
+
+/*
+ * Record the timestamp that is associated with a WAL position.
+ *
+ * This is called by walreceiver on standby servers when new messages arrive,
+ * using a timestamp and the latest known WAL position from the upstream
+ * server.  The timestamp will be sent back to the upstream server via
+ * walreceiver when the recovery process has applied the WAL position.  The
+ * upstream server can then compute the elapsed time to estimate the replay
+ * lag.
+ */
+void
+SetXLogReplayTimestampAtLsn(TimestampTz timestamp, XLogRecPtr lsn)
+{
+	Assert(AmWalReceiverProcess());
+
+	SpinLockAcquire(&XLogCtl->info_lck);
+	if (lsn == XLogCtl->lastReplayedEndRecPtr)
+	{
+		/*
+		 * That is the last replayed LSN: we are fully replayed, so we can
+		 * update the replay timestamp immediately.
+		 */
+		XLogCtl->lastReplayedTimestamp = timestamp;
+	}
+	else
+	{
+		/*
+		 * There is WAL still to be applied.  We will associate the timestamp
+		 * with this WAL position and wait for it to be replayed.  We add it
+		 * at the 'write' end of the circular buffer of LSN/timestamp
+		 * mappings, which the replay loop will eventually read.
+		 */
+		uint32 write_head = XLogCtl->timestamps.write_head;
+		uint32 new_write_head = (write_head + 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+
+		if (new_write_head == XLogCtl->timestamps.read_head)
+		{
+			/*
+			 * The buffer is full, so we'll rewind and overwrite the most
+			 * recent sample.  Overwriting the most recent sample means that
+			 * if we're not replaying fast enough and the buffer fills up,
+			 * we'll effectively lower the sampling rate.
+			 */
+			new_write_head = write_head;
+			write_head = (write_head - 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+		}
+
+		XLogCtl->timestamps.buffer[write_head].lsn = lsn;
+		XLogCtl->timestamps.buffer[write_head].timestamp = timestamp;
+		XLogCtl->timestamps.write_head = new_write_head;
+	}
+	SpinLockRelease(&XLogCtl->info_lck);
+}
+
+/*
+ * Get the timestamp for the most recently applied WAL record that carried a
+ * timestamp from the upstream server, and also the most recently applied LSN.
+ * (Note that the timestamp and the LSN don't necessarily relate to the same
+ * record.)
+ *
+ * This is similar to GetLatestXTime, except that it is advanced when WAL
+ * positions recorded with SetXLogReplayTimestampAtLsn have been applied,
+ * rather than commit records.
+ */
+TimestampTz
+GetXLogReplayTimestamp(XLogRecPtr *lsn)
+{
+	TimestampTz result;
+
+	SpinLockAcquire(&XLogCtl->info_lck);
+	if (lsn)
+		*lsn = XLogCtl->lastReplayedEndRecPtr;
+	result = XLogCtl->lastReplayedTimestamp;
+	SpinLockRelease(&XLogCtl->info_lck);
+
+	return result;
+}
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index e011af1..a070844 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -679,6 +679,7 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
index 2bb3dce..f5a10e9 100644
--- a/src/backend/replication/walreceiver.c
+++ b/src/backend/replication/walreceiver.c
@@ -73,6 +73,7 @@
 int			wal_receiver_status_interval;
 int			wal_receiver_timeout;
 bool		hot_standby_feedback;
+int			replay_lag_sample_interval;
 
 /* libpqreceiver hooks to these when loaded */
 walrcv_connect_type walrcv_connect = NULL;
@@ -145,7 +146,7 @@ static void WalRcvDie(int code, Datum arg);
 static void XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len);
 static void XLogWalRcvWrite(char *buf, Size nbytes, XLogRecPtr recptr);
 static void XLogWalRcvFlush(bool dying);
-static void XLogWalRcvSendReply(bool force, bool requestReply);
+static void XLogWalRcvSendReply(bool force, bool requestReply, bool includeApplyTimestamp);
 static void XLogWalRcvSendHSFeedback(bool immed);
 static void ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime);
 
@@ -457,7 +458,7 @@ WalReceiverMain(void)
 					}
 
 					/* Let the master know that we received some data. */
-					XLogWalRcvSendReply(false, false);
+					XLogWalRcvSendReply(false, false, false);
 
 					/*
 					 * If we've written some records, flush them to disk and
@@ -494,6 +495,8 @@ WalReceiverMain(void)
 					ResetLatch(&walrcv->latch);
 					if (walrcv->force_reply)
 					{
+						bool timestamp = walrcv->force_reply_apply_timestamp;
+
 						/*
 						 * The recovery process has asked us to send apply
 						 * feedback now.  Make sure the flag is really set to
@@ -501,8 +504,9 @@ WalReceiverMain(void)
 						 * we don't miss a new request for a reply.
 						 */
 						walrcv->force_reply = false;
+						walrcv->force_reply_apply_timestamp = false;
 						pg_memory_barrier();
-						XLogWalRcvSendReply(true, false);
+						XLogWalRcvSendReply(true, false, timestamp);
 					}
 				}
 				if (rc & WL_POSTMASTER_DEATH)
@@ -560,7 +564,7 @@ WalReceiverMain(void)
 						}
 					}
 
-					XLogWalRcvSendReply(requestReply, requestReply);
+					XLogWalRcvSendReply(requestReply, requestReply, false);
 					XLogWalRcvSendHSFeedback(false);
 				}
 			}
@@ -911,7 +915,7 @@ XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len)
 
 				/* If the primary requested a reply, send one immediately */
 				if (replyRequested)
-					XLogWalRcvSendReply(true, false);
+					XLogWalRcvSendReply(true, false, false);
 				break;
 			}
 		default:
@@ -1074,7 +1078,7 @@ XLogWalRcvFlush(bool dying)
 		/* Also let the master know that we made some progress */
 		if (!dying)
 		{
-			XLogWalRcvSendReply(false, false);
+			XLogWalRcvSendReply(false, false, false);
 			XLogWalRcvSendHSFeedback(false);
 		}
 	}
@@ -1092,15 +1096,18 @@ XLogWalRcvFlush(bool dying)
  * If 'requestReply' is true, requests the server to reply immediately upon
  * receiving this message. This is used for heartbearts, when approaching
  * wal_receiver_timeout.
+ *
+ * If 'reportApplyTimestamp' is true, the latest apply timestamp is included.
  */
 static void
-XLogWalRcvSendReply(bool force, bool requestReply)
+XLogWalRcvSendReply(bool force, bool requestReply, bool reportApplyTimestamp)
 {
 	static XLogRecPtr writePtr = 0;
 	static XLogRecPtr flushPtr = 0;
 	XLogRecPtr	applyPtr;
 	static TimestampTz sendTime = 0;
 	TimestampTz now;
+	TimestampTz applyTimestamp = 0;
 
 	/*
 	 * If the user doesn't want status to be reported to the master, be sure
@@ -1132,7 +1139,35 @@ XLogWalRcvSendReply(bool force, bool requestReply)
 	/* Construct a new message */
 	writePtr = LogstreamResult.Write;
 	flushPtr = LogstreamResult.Flush;
-	applyPtr = GetXLogReplayRecPtr(NULL);
+	applyTimestamp = GetXLogReplayTimestamp(&applyPtr);
+
+	/* Decide whether to send an apply timestamp for replay lag estimation. */
+	if (replay_lag_sample_interval != -1)
+	{
+		static TimestampTz lastTimestampSendTime = 0;
+
+		/*
+		 * Only send an apply timestamp if we were explicitly asked to by the
+		 * recovery process or if replay lag sampling is active but the
+		 * recovery process seems to be stuck.
+		 *
+		 * If we haven't heard from the recovery process in a time exceeding
+		 * wal_receiver_status_interval and yet it has not applied the highest
+		 * LSN we've heard about, then we want to resend the last replayed
+		 * timestamp we have; otherwise we zero it out and wait for the
+		 * recovery process to wake us when it has set a new accurate replay
+		 * timestamp.  Note that we can read latestWalEnd without acquiring the
+		 * mutex that protects it because it is only written to by this
+		 * process (walreceiver).
+		 */
+		if (reportApplyTimestamp ||
+			(WalRcv->latestWalEnd > applyPtr &&
+			 TimestampDifferenceExceeds(lastTimestampSendTime, now,
+										wal_receiver_status_interval * 1000)))
+			lastTimestampSendTime = now;
+		else
+			applyTimestamp = 0;
+	}
 
 	resetStringInfo(&reply_message);
 	pq_sendbyte(&reply_message, 'r');
@@ -1140,6 +1175,7 @@ XLogWalRcvSendReply(bool force, bool requestReply)
 	pq_sendint64(&reply_message, flushPtr);
 	pq_sendint64(&reply_message, applyPtr);
 	pq_sendint64(&reply_message, GetCurrentIntegerTimestamp());
+	pq_sendint64(&reply_message, TimestampTzToIntegerTimestamp(applyTimestamp));
 	pq_sendbyte(&reply_message, requestReply ? 1 : 0);
 
 	/* Send it */
@@ -1244,18 +1280,40 @@ static void
 ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
 {
 	WalRcvData *walrcv = WalRcv;
-
 	TimestampTz lastMsgReceiptTime = GetCurrentTimestamp();
+	bool newHighWalEnd = false;
+
+	static TimestampTz lastRecordedTimestamp = 0;
 
 	/* Update shared-memory status */
 	SpinLockAcquire(&walrcv->mutex);
 	if (walrcv->latestWalEnd < walEnd)
+	{
 		walrcv->latestWalEndTime = sendTime;
+		newHighWalEnd = true;
+	}
 	walrcv->latestWalEnd = walEnd;
 	walrcv->lastMsgSendTime = sendTime;
 	walrcv->lastMsgReceiptTime = lastMsgReceiptTime;
 	SpinLockRelease(&walrcv->mutex);
 
+	/*
+	 * If replay lag sampling is active, remember the upstream server's
+	 * timestamp at the latest WAL end that it has, unless we've already
+	 * done that too recently or the LSN hasn't advanced.  This timestamp
+	 * will be fed back to us by the startup process when it eventually
+	 * replays this LSN, so that we can feed it back to the upstream server
+	 * for replay lag tracking purposes.
+	 */
+	if (replay_lag_sample_interval != -1 &&
+		newHighWalEnd &&
+		sendTime > TimestampTzPlusMilliseconds(lastRecordedTimestamp,
+											   replay_lag_sample_interval))
+	{
+		SetXLogReplayTimestampAtLsn(sendTime, walEnd);
+		lastRecordedTimestamp = sendTime;
+	}
+
 	if (log_min_messages <= DEBUG2)
 	{
 		char	   *sendtime;
@@ -1291,12 +1349,14 @@ ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
  * This is called by the startup process whenever interesting xlog records
  * are applied, so that walreceiver can check if it needs to send an apply
  * notification back to the master which may be waiting in a COMMIT with
- * synchronous_commit = remote_apply.
+ * synchronous_commit = remote_apply.  Also used to send periodic messages
+ * which are used to compute pg_stat_replication.replay_lag.
  */
 void
-WalRcvForceReply(void)
+WalRcvForceReply(bool apply_timestamp)
 {
 	WalRcv->force_reply = true;
+	WalRcv->force_reply_apply_timestamp = apply_timestamp;
 	SetLatch(&WalRcv->latch);
 }
 
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index bc5e508..b6211a5 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1545,15 +1545,29 @@ ProcessStandbyReplyMessage(void)
 	XLogRecPtr	writePtr,
 				flushPtr,
 				applyPtr;
+	int64		applyLagUs;
 	bool		replyRequested;
+	TimestampTz now = GetCurrentTimestamp();
+	TimestampTz applyTimestamp;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
 	flushPtr = pq_getmsgint64(&reply_message);
 	applyPtr = pq_getmsgint64(&reply_message);
 	(void) pq_getmsgint64(&reply_message);		/* sendTime; not used ATM */
+	applyTimestamp = IntegerTimestampToTimestampTz(pq_getmsgint64(&reply_message));
 	replyRequested = pq_getmsgbyte(&reply_message);
 
+	/* Compute the apply lag in milliseconds. */
+	if (applyTimestamp == 0)
+		applyLagUs = -1;
+	else
+#ifdef HAVE_INT64_TIMESTAMP
+		applyLagUs = now - applyTimestamp;
+#else
+		applyLagUs = (now - applyTimestamp) * 1000000;
+#endif
+
 	elog(DEBUG2, "write %X/%X flush %X/%X apply %X/%X%s",
 		 (uint32) (writePtr >> 32), (uint32) writePtr,
 		 (uint32) (flushPtr >> 32), (uint32) flushPtr,
@@ -1575,6 +1589,8 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (applyLagUs >= 0)
+			walsnd->applyLagUs = applyLagUs;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1971,6 +1987,7 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->applyLagUs = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2753,7 +2770,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	9
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2801,6 +2818,7 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		int64		applyLagUs;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2815,6 +2833,7 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		applyLagUs = walsnd->applyLagUs;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2849,6 +2868,23 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 				nulls[5] = true;
 			values[5] = LSNGetDatum(apply);
 
+			if (applyLagUs < 0)
+				nulls[6] = true;
+			else
+			{
+				Interval *applyLagInterval = palloc(sizeof(Interval));
+
+				applyLagInterval->month = 0;
+				applyLagInterval->day = 0;
+#ifdef HAVE_INT64_TIMESTAMP
+				applyLagInterval->time = applyLagUs;
+#else
+				applyLagInterval->time = applyLagUs / 1000000.0;
+#endif
+				nulls[6] = false;
+				values[6] = IntervalPGetDatum(applyLagInterval);
+			}
+
 			/*
 			 * Treat a standby such as a pg_basebackup background process
 			 * which always returns an invalid flush location, as an
@@ -2856,18 +2892,18 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			values[7] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
 			 * informational, not different from priority.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[8] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = CStringGetTextDatum("sync");
+				values[8] = CStringGetTextDatum("sync");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[8] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index c1d6f05..323d640 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -1724,6 +1724,20 @@ GetSQLLocalTimestamp(int32 typmod)
 }
 
 /*
+ * TimestampTzToIntegerTimestamp -- convert a native timestamp to int64 format
+ *
+ * When compiled with --enable-integer-datetimes, this is implemented as a
+ * no-op macro.
+ */
+#ifndef HAVE_INT64_TIMESTAMP
+int64
+TimestampTzToIntegerTimestamp(TimestampTz timestamp)
+{
+	return timestamp * 1000000;
+}
+#endif
+
+/*
  * TimestampDifference -- convert the difference between two timestamps
  *		into integer seconds and microseconds
  *
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index da74f00..7551a0e 100644
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -1810,6 +1810,17 @@ static struct config_int ConfigureNamesInt[] =
 	},
 
 	{
+		{"replay_lag_sample_interval", PGC_SIGHUP, REPLICATION_STANDBY,
+			gettext_noop("Sets the minimum time between WAL timestamp samples used to estimate replay lag."),
+			NULL,
+			GUC_UNIT_MS
+		},
+		&replay_lag_sample_interval,
+		1 * 1000, -1, INT_MAX / 1000,
+		NULL, NULL, NULL
+	},
+
+	{
 		{"wal_receiver_timeout", PGC_SIGHUP, REPLICATION_STANDBY,
 			gettext_noop("Sets the maximum wait time to receive data from the primary."),
 			NULL,
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index 7c2daa5..53d9f4b 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -271,6 +271,8 @@
 					# in milliseconds; 0 disables
 #wal_retrieve_retry_interval = 5s	# time to wait before retrying to
 					# retrieve WAL after a failed attempt
+#replay_lag_sample_interval = 1s	# min time between timestamps recorded
+					# to estimate replay lag; -1 disables replay lag sampling
 
 
 #------------------------------------------------------------------------------
diff --git a/src/bin/pg_basebackup/pg_recvlogical.c b/src/bin/pg_basebackup/pg_recvlogical.c
index cb5f989..9753648 100644
--- a/src/bin/pg_basebackup/pg_recvlogical.c
+++ b/src/bin/pg_basebackup/pg_recvlogical.c
@@ -111,7 +111,7 @@ sendFeedback(PGconn *conn, int64 now, bool force, bool replyRequested)
 	static XLogRecPtr last_written_lsn = InvalidXLogRecPtr;
 	static XLogRecPtr last_fsync_lsn = InvalidXLogRecPtr;
 
-	char		replybuf[1 + 8 + 8 + 8 + 8 + 1];
+	char		replybuf[1 + 8 + 8 + 8 + 8 + 8 + 1];
 	int			len = 0;
 
 	/*
@@ -142,6 +142,8 @@ sendFeedback(PGconn *conn, int64 now, bool force, bool replyRequested)
 	len += 8;
 	fe_sendint64(now, &replybuf[len]);	/* sendTime */
 	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* applyTimestamp */
+	len += 8;
 	replybuf[len] = replyRequested ? 1 : 0;		/* replyRequested */
 	len += 1;
 
diff --git a/src/bin/pg_basebackup/receivelog.c b/src/bin/pg_basebackup/receivelog.c
index 4382e5d..8e89627 100644
--- a/src/bin/pg_basebackup/receivelog.c
+++ b/src/bin/pg_basebackup/receivelog.c
@@ -321,7 +321,7 @@ writeTimeLineHistoryFile(StreamCtl *stream, char *filename, char *content)
 static bool
 sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested)
 {
-	char		replybuf[1 + 8 + 8 + 8 + 8 + 1];
+	char		replybuf[1 + 8 + 8 + 8 + 8 + 8 + 1];
 	int			len = 0;
 
 	replybuf[len] = 'r';
@@ -337,6 +337,8 @@ sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested)
 	len += 8;
 	fe_sendint64(now, &replybuf[len]);	/* sendTime */
 	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* applyTimestamp */
+	len += 8;
 	replybuf[len] = replyRequested ? 1 : 0;		/* replyRequested */
 	len += 1;
 
diff --git a/src/include/access/xlog.h b/src/include/access/xlog.h
index c9f332c..1be2f34 100644
--- a/src/include/access/xlog.h
+++ b/src/include/access/xlog.h
@@ -237,6 +237,9 @@ extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
 extern XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI);
 extern XLogRecPtr GetXLogInsertRecPtr(void);
 extern XLogRecPtr GetXLogWriteRecPtr(void);
+extern void SetXLogReplayTimestamp(TimestampTz timestamp);
+extern void SetXLogReplayTimestampAtLsn(TimestampTz timestamp, XLogRecPtr lsn);
+extern TimestampTz GetXLogReplayTimestamp(XLogRecPtr *lsn);
 extern bool RecoveryIsPaused(void);
 extern void SetRecoveryPause(bool recoveryPause);
 extern TimestampTz GetLatestXTime(void);
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index 047a1ce..6c49713 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2766,7 +2766,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,23,25}" "{o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walreceiver.h b/src/include/replication/walreceiver.h
index cd787c9..9a64bda 100644
--- a/src/include/replication/walreceiver.h
+++ b/src/include/replication/walreceiver.h
@@ -23,6 +23,7 @@
 extern int	wal_receiver_status_interval;
 extern int	wal_receiver_timeout;
 extern bool hot_standby_feedback;
+extern int	replay_lag_sample_interval;
 
 /*
  * MAXCONNINFO: maximum size of a connection string.
@@ -119,6 +120,9 @@ typedef struct
 	 */
 	bool		force_reply;
 
+	/* include the latest replayed timestamp when replying? */
+	bool		force_reply_apply_timestamp;
+
 	/* set true once conninfo is ready to display (obfuscated pwds etc) */
 	bool		ready_to_display;
 
@@ -176,6 +180,6 @@ extern void RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr,
 extern XLogRecPtr GetWalRcvWriteRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI);
 extern int	GetReplicationApplyDelay(void);
 extern int	GetReplicationTransferLatency(void);
-extern void WalRcvForceReply(void);
+extern void WalRcvForceReply(bool sendApplyTimestamp);
 
 #endif   /* _WALRECEIVER_H */
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 7794aa5..4de43e8 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -46,6 +46,7 @@ typedef struct WalSnd
 	XLogRecPtr	write;
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
+	int64		applyLagUs;
 
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
diff --git a/src/include/utils/timestamp.h b/src/include/utils/timestamp.h
index 93b90fe..20517c9 100644
--- a/src/include/utils/timestamp.h
+++ b/src/include/utils/timestamp.h
@@ -233,9 +233,11 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time,
 #ifndef HAVE_INT64_TIMESTAMP
 extern int64 GetCurrentIntegerTimestamp(void);
 extern TimestampTz IntegerTimestampToTimestampTz(int64 timestamp);
+extern int64 TimestampTzToIntegerTimestamp(TimestampTz timestamp);
 #else
 #define GetCurrentIntegerTimestamp()	GetCurrentTimestamp()
 #define IntegerTimestampToTimestampTz(timestamp) (timestamp)
+#define TimestampTzToIntegerTimestamp(timestamp) (timestamp)
 #endif
 
 extern TimestampTz time_t_to_timestamptz(pg_time_t tm);
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 031e8c2..8fbdeae 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1804,10 +1804,11 @@ pg_stat_replication| SELECT s.pid,
     w.write_location,
     w.flush_location,
     w.replay_location,
+    w.replay_lag,
     w.sync_priority,
     w.sync_state
    FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn)
-     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) ON ((s.pid = w.pid)))
+     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, replay_lag, sync_priority, sync_state) ON ((s.pid = w.pid)))
      LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
 pg_stat_ssl| SELECT s.pid,
     s.ssl,

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 3b614b6..36e00e0 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -3282,6 +3282,26 @@ include_dir 'conf.d'
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-relay-lag-sample-interval" xreflabel="replay_lag_sample_interval">
+      <term><varname>replay_lag_sample_interval</varname> (<type>integer</type>)
+      <indexterm>
+       <primary><varname>replay_lag_sample_interval</> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls how often a standby should sample replay lag information to
+        send back to the primary or upstream standby while replaying WAL.  The
+        default is 1 second.  Units are milliseconds if not specified.  A
+        value of -1 disables the reporting of replay lag.  Estimated replay lag
+        can be seen in the <link linkend="monitoring-stats-views-table">
+        <literal>pg_stat_replication</></link> view of the upstream server.
+        This parameter can only be set
+        in the <filename>postgresql.conf</> file or on the server command line.
+       </para>
+      </listitem>
+     </varlistentry>
+
      <varlistentry id="guc-hot-standby-feedback" xreflabel="hot_standby_feedback">
       <term><varname>hot_standby_feedback</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 5b58d2e..79d2d95 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1401,6 +1401,12 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be replayed on this
+      standby server</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index aa9ee5a..739e45e 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -82,6 +82,8 @@ extern uint32 bootstrap_data_checksum_version;
 #define PROMOTE_SIGNAL_FILE		"promote"
 #define FALLBACK_PROMOTE_SIGNAL_FILE "fallback_promote"
 
+/* Size of the circular buffer of timestamped LSNs. */
+#define XLOG_TIMESTAMP_BUFFER_SIZE 8192
 
 /* User-settable parameters */
 int			max_wal_size = 64;	/* 1 GB */
@@ -520,6 +522,26 @@ typedef struct XLogCtlInsert
 } XLogCtlInsert;
 
 /*
+ * A sample associating a timestamp with a given xlog position.
+ */
+typedef struct XLogTimestamp
+{
+	TimestampTz	timestamp;
+	XLogRecPtr	lsn;
+} XLogTimestamp;
+
+/*
+ * A circular buffer of LSNs and associated timestamps.  The buffer is empty
+ * when read_head == write_head.
+ */
+typedef struct XLogTimestampBuffer
+{
+	uint32			read_head;
+	uint32			write_head;
+	XLogTimestamp	buffer[XLOG_TIMESTAMP_BUFFER_SIZE];
+} XLogTimestampBuffer;
+
+/*
  * Total shared-memory state for XLOG.
  */
 typedef struct XLogCtlData
@@ -637,6 +659,12 @@ typedef struct XLogCtlData
 	/* timestamp of last COMMIT/ABORT record replayed (or being replayed) */
 	TimestampTz recoveryLastXTime;
 
+	/* timestamp from the most recently applied record associated with a timestamp. */
+	TimestampTz lastReplayedTimestamp;
+
+	/* a buffer of upstream timestamps for WAL that is not yet applied. */
+	XLogTimestampBuffer timestamps;
+
 	/*
 	 * timestamp of when we started replaying the current chunk of WAL data,
 	 * only relevant for replication or archive recovery
@@ -5976,6 +6004,44 @@ CheckRequiredParameterValues(void)
 }
 
 /*
+ * Called by the startup process after it has replayed up to 'lsn'.  Checks
+ * for timestamps associated with WAL positions that have now been replayed.
+ * If any are found, the latest such timestamp found is written to
+ * '*timestamp'.  Returns the new buffer read head position, which the caller
+ * should write into XLogCtl->timestamps.read_head while holding info_lck.
+ */
+static uint32
+CheckForReplayedTimestamps(XLogRecPtr lsn, TimestampTz *timestamp)
+{
+	uint32 read_head;
+
+	/*
+	 * It's OK to access timestamps.read_head without any kind synchronization
+	 * because this process is the only one to write to it.
+	 */
+	Assert(AmStartupProcess());
+	read_head = XLogCtl->timestamps.read_head;
+
+	/*
+	 * It's OK to access write_head without interlocking because it's an
+	 * aligned 32 bit value which we can read atomically on all supported
+	 * platforms to get some recent value, not a torn/garbage value.
+	 * Furthermore we must see a value that is at least as recent as any WAL
+	 * that we have replayed, because walreceiver calls
+	 * SetXLogReplayTimestampAtLsn before passing the corresponding WAL data
+	 * to the recovery process.
+	 */
+	while (read_head != XLogCtl->timestamps.write_head &&
+		   XLogCtl->timestamps.buffer[read_head].lsn <= lsn)
+	{
+		*timestamp = XLogCtl->timestamps.buffer[read_head].timestamp;
+		read_head = (read_head + 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+	}
+
+	return read_head;
+}
+
+/*
  * This must be called ONCE during postmaster or standalone-backend startup
  */
 void
@@ -6794,6 +6860,8 @@ StartupXLOG(void)
 			do
 			{
 				bool		switchedTLI = false;
+				TimestampTz	replayed_timestamp = 0;
+				uint32		timestamp_read_head;
 
 #ifdef WAL_DEBUG
 				if (XLOG_DEBUG ||
@@ -6947,24 +7015,34 @@ StartupXLOG(void)
 				/* Pop the error context stack */
 				error_context_stack = errcallback.previous;
 
+				/* Check if we have replayed a timestamped WAL position */
+				timestamp_read_head =
+					CheckForReplayedTimestamps(EndRecPtr, &replayed_timestamp);
+
 				/*
-				 * Update lastReplayedEndRecPtr after this record has been
-				 * successfully replayed.
+				 * Update lastReplayedEndRecPtr and lastReplayedTimestamp
+				 * after this record has been successfully replayed.
 				 */
 				SpinLockAcquire(&XLogCtl->info_lck);
 				XLogCtl->lastReplayedEndRecPtr = EndRecPtr;
 				XLogCtl->lastReplayedTLI = ThisTimeLineID;
+				XLogCtl->timestamps.read_head = timestamp_read_head;
+				if (replayed_timestamp != 0)
+					XLogCtl->lastReplayedTimestamp = replayed_timestamp;
 				SpinLockRelease(&XLogCtl->info_lck);
 
 				/*
 				 * If rm_redo called XLogRequestWalReceiverReply, then we wake
 				 * up the receiver so that it notices the updated
-				 * lastReplayedEndRecPtr and sends a reply to the master.
+				 * lastReplayedEndRecPtr and sends a reply to the master.  We
+				 * also wake it if we have replayed a WAL position that has
+				 * an associated timestamp so that the upstream server can
+				 * measure our replay lag.
 				 */
-				if (doRequestWalReceiverReply)
+				if (doRequestWalReceiverReply || replayed_timestamp != 0)
 				{
 					doRequestWalReceiverReply = false;
-					WalRcvForceReply();
+					WalRcvForceReply(replayed_timestamp != 0);
 				}
 
 				/* Remember this record as the last-applied one */
@@ -11745,3 +11823,81 @@ XLogRequestWalReceiverReply(void)
 {
 	doRequestWalReceiverReply = true;
 }
+
+/*
+ * Record the timestamp that is associated with a WAL position.
+ *
+ * This is called by walreceiver on standby servers when new messages arrive,
+ * using a timestamp and the latest known WAL position from the upstream
+ * server.  The timestamp will be sent back to the upstream server via
+ * walreceiver when the recovery process has applied the WAL position.  The
+ * upstream server can then compute the elapsed time to estimate the replay
+ * lag.
+ */
+void
+SetXLogReplayTimestampAtLsn(TimestampTz timestamp, XLogRecPtr lsn)
+{
+	Assert(AmWalReceiverProcess());
+
+	SpinLockAcquire(&XLogCtl->info_lck);
+	if (lsn == XLogCtl->lastReplayedEndRecPtr)
+	{
+		/*
+		 * That is the last replayed LSN: we are fully replayed, so we can
+		 * update the replay timestamp immediately.
+		 */
+		XLogCtl->lastReplayedTimestamp = timestamp;
+	}
+	else
+	{
+		/*
+		 * There is WAL still to be applied.  We will associate the timestamp
+		 * with this WAL position and wait for it to be replayed.  We add it
+		 * at the 'write' end of the circular buffer of LSN/timestamp
+		 * mappings, which the replay loop will eventually read.
+		 */
+		uint32 write_head = XLogCtl->timestamps.write_head;
+		uint32 new_write_head = (write_head + 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+
+		if (new_write_head == XLogCtl->timestamps.read_head)
+		{
+			/*
+			 * The buffer is full, so we'll rewind and overwrite the most
+			 * recent sample.  Overwriting the most recent sample means that
+			 * if we're not replaying fast enough and the buffer fills up,
+			 * we'll effectively lower the sampling rate.
+			 */
+			new_write_head = write_head;
+			write_head = (write_head - 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+		}
+
+		XLogCtl->timestamps.buffer[write_head].lsn = lsn;
+		XLogCtl->timestamps.buffer[write_head].timestamp = timestamp;
+		XLogCtl->timestamps.write_head = new_write_head;
+	}
+	SpinLockRelease(&XLogCtl->info_lck);
+}
+
+/*
+ * Get the timestamp for the most recently applied WAL record that carried a
+ * timestamp from the upstream server, and also the most recently applied LSN.
+ * (Note that the timestamp and the LSN don't necessarily relate to the same
+ * record.)
+ *
+ * This is similar to GetLatestXTime, except that it is advanced when WAL
+ * positions recorded with SetXLogReplayTimestampAtLsn have been applied,
+ * rather than commit records.
+ */
+TimestampTz
+GetXLogReplayTimestamp(XLogRecPtr *lsn)
+{
+	TimestampTz result;
+
+	SpinLockAcquire(&XLogCtl->info_lck);
+	if (lsn)
+		*lsn = XLogCtl->lastReplayedEndRecPtr;
+	result = XLogCtl->lastReplayedTimestamp;
+	SpinLockRelease(&XLogCtl->info_lck);
+
+	return result;
+}
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 48e7c4b..e0e45fa 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -685,6 +685,7 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
index cc3cf7d..9cf9f4c 100644
--- a/src/backend/replication/walreceiver.c
+++ b/src/backend/replication/walreceiver.c
@@ -73,6 +73,7 @@
 int			wal_receiver_status_interval;
 int			wal_receiver_timeout;
 bool		hot_standby_feedback;
+int			replay_lag_sample_interval;
 
 /* libpqwalreceiver connection */
 static WalReceiverConn *wrconn = NULL;
@@ -138,7 +139,7 @@ static void WalRcvDie(int code, Datum arg);
 static void XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len);
 static void XLogWalRcvWrite(char *buf, Size nbytes, XLogRecPtr recptr);
 static void XLogWalRcvFlush(bool dying);
-static void XLogWalRcvSendReply(bool force, bool requestReply);
+static void XLogWalRcvSendReply(bool force, bool requestReply, bool includeApplyTimestamp);
 static void XLogWalRcvSendHSFeedback(bool immed);
 static void ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime);
 
@@ -456,7 +457,7 @@ WalReceiverMain(void)
 					}
 
 					/* Let the master know that we received some data. */
-					XLogWalRcvSendReply(false, false);
+					XLogWalRcvSendReply(false, false, false);
 
 					/*
 					 * If we've written some records, flush them to disk and
@@ -493,6 +494,8 @@ WalReceiverMain(void)
 					ResetLatch(walrcv->latch);
 					if (walrcv->force_reply)
 					{
+						bool timestamp = walrcv->force_reply_apply_timestamp;
+
 						/*
 						 * The recovery process has asked us to send apply
 						 * feedback now.  Make sure the flag is really set to
@@ -500,8 +503,9 @@ WalReceiverMain(void)
 						 * we don't miss a new request for a reply.
 						 */
 						walrcv->force_reply = false;
+						walrcv->force_reply_apply_timestamp = false;
 						pg_memory_barrier();
-						XLogWalRcvSendReply(true, false);
+						XLogWalRcvSendReply(true, false, timestamp);
 					}
 				}
 				if (rc & WL_POSTMASTER_DEATH)
@@ -559,7 +563,7 @@ WalReceiverMain(void)
 						}
 					}
 
-					XLogWalRcvSendReply(requestReply, requestReply);
+					XLogWalRcvSendReply(requestReply, requestReply, false);
 					XLogWalRcvSendHSFeedback(false);
 				}
 			}
@@ -911,7 +915,7 @@ XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len)
 
 				/* If the primary requested a reply, send one immediately */
 				if (replyRequested)
-					XLogWalRcvSendReply(true, false);
+					XLogWalRcvSendReply(true, false, false);
 				break;
 			}
 		default:
@@ -1074,7 +1078,7 @@ XLogWalRcvFlush(bool dying)
 		/* Also let the master know that we made some progress */
 		if (!dying)
 		{
-			XLogWalRcvSendReply(false, false);
+			XLogWalRcvSendReply(false, false, false);
 			XLogWalRcvSendHSFeedback(false);
 		}
 	}
@@ -1092,15 +1096,18 @@ XLogWalRcvFlush(bool dying)
  * If 'requestReply' is true, requests the server to reply immediately upon
  * receiving this message. This is used for heartbearts, when approaching
  * wal_receiver_timeout.
+ *
+ * If 'reportApplyTimestamp' is true, the latest apply timestamp is included.
  */
 static void
-XLogWalRcvSendReply(bool force, bool requestReply)
+XLogWalRcvSendReply(bool force, bool requestReply, bool reportApplyTimestamp)
 {
 	static XLogRecPtr writePtr = 0;
 	static XLogRecPtr flushPtr = 0;
 	XLogRecPtr	applyPtr;
 	static TimestampTz sendTime = 0;
 	TimestampTz now;
+	TimestampTz applyTimestamp = 0;
 
 	/*
 	 * If the user doesn't want status to be reported to the master, be sure
@@ -1132,7 +1139,35 @@ XLogWalRcvSendReply(bool force, bool requestReply)
 	/* Construct a new message */
 	writePtr = LogstreamResult.Write;
 	flushPtr = LogstreamResult.Flush;
-	applyPtr = GetXLogReplayRecPtr(NULL);
+	applyTimestamp = GetXLogReplayTimestamp(&applyPtr);
+
+	/* Decide whether to send an apply timestamp for replay lag estimation. */
+	if (replay_lag_sample_interval != -1)
+	{
+		static TimestampTz lastTimestampSendTime = 0;
+
+		/*
+		 * Only send an apply timestamp if we were explicitly asked to by the
+		 * recovery process or if replay lag sampling is active but the
+		 * recovery process seems to be stuck.
+		 *
+		 * If we haven't heard from the recovery process in a time exceeding
+		 * wal_receiver_status_interval and yet it has not applied the highest
+		 * LSN we've heard about, then we want to resend the last replayed
+		 * timestamp we have; otherwise we zero it out and wait for the
+		 * recovery process to wake us when it has set a new accurate replay
+		 * timestamp.  Note that we can read latestWalEnd without acquiring the
+		 * mutex that protects it because it is only written to by this
+		 * process (walreceiver).
+		 */
+		if (reportApplyTimestamp ||
+			(WalRcv->latestWalEnd > applyPtr &&
+			 TimestampDifferenceExceeds(lastTimestampSendTime, now,
+										wal_receiver_status_interval * 1000)))
+			lastTimestampSendTime = now;
+		else
+			applyTimestamp = 0;
+	}
 
 	resetStringInfo(&reply_message);
 	pq_sendbyte(&reply_message, 'r');
@@ -1140,6 +1175,7 @@ XLogWalRcvSendReply(bool force, bool requestReply)
 	pq_sendint64(&reply_message, flushPtr);
 	pq_sendint64(&reply_message, applyPtr);
 	pq_sendint64(&reply_message, GetCurrentIntegerTimestamp());
+	pq_sendint64(&reply_message, TimestampTzToIntegerTimestamp(applyTimestamp));
 	pq_sendbyte(&reply_message, requestReply ? 1 : 0);
 
 	/* Send it */
@@ -1244,18 +1280,40 @@ static void
 ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
 {
 	WalRcvData *walrcv = WalRcv;
-
 	TimestampTz lastMsgReceiptTime = GetCurrentTimestamp();
+	bool newHighWalEnd = false;
+
+	static TimestampTz lastRecordedTimestamp = 0;
 
 	/* Update shared-memory status */
 	SpinLockAcquire(&walrcv->mutex);
 	if (walrcv->latestWalEnd < walEnd)
+	{
 		walrcv->latestWalEndTime = sendTime;
+		newHighWalEnd = true;
+	}
 	walrcv->latestWalEnd = walEnd;
 	walrcv->lastMsgSendTime = sendTime;
 	walrcv->lastMsgReceiptTime = lastMsgReceiptTime;
 	SpinLockRelease(&walrcv->mutex);
 
+	/*
+	 * If replay lag sampling is active, remember the upstream server's
+	 * timestamp at the latest WAL end that it has, unless we've already
+	 * done that too recently or the LSN hasn't advanced.  This timestamp
+	 * will be fed back to us by the startup process when it eventually
+	 * replays this LSN, so that we can feed it back to the upstream server
+	 * for replay lag tracking purposes.
+	 */
+	if (replay_lag_sample_interval != -1 &&
+		newHighWalEnd &&
+		sendTime > TimestampTzPlusMilliseconds(lastRecordedTimestamp,
+											   replay_lag_sample_interval))
+	{
+		SetXLogReplayTimestampAtLsn(sendTime, walEnd);
+		lastRecordedTimestamp = sendTime;
+	}
+
 	if (log_min_messages <= DEBUG2)
 	{
 		char	   *sendtime;
@@ -1291,12 +1349,14 @@ ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
  * This is called by the startup process whenever interesting xlog records
  * are applied, so that walreceiver can check if it needs to send an apply
  * notification back to the master which may be waiting in a COMMIT with
- * synchronous_commit = remote_apply.
+ * synchronous_commit = remote_apply.  Also used to send periodic messages
+ * which are used to compute pg_stat_replication.replay_lag.
  */
 void
-WalRcvForceReply(void)
+WalRcvForceReply(bool apply_timestamp)
 {
 	WalRcv->force_reply = true;
+	WalRcv->force_reply_apply_timestamp = apply_timestamp;
 	if (WalRcv->latch)
 		SetLatch(WalRcv->latch);
 }
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index d80bcc0..0782d78 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1553,15 +1553,29 @@ ProcessStandbyReplyMessage(void)
 	XLogRecPtr	writePtr,
 				flushPtr,
 				applyPtr;
+	int64		applyLagUs;
 	bool		replyRequested;
+	TimestampTz now = GetCurrentTimestamp();
+	TimestampTz applyTimestamp;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
 	flushPtr = pq_getmsgint64(&reply_message);
 	applyPtr = pq_getmsgint64(&reply_message);
 	(void) pq_getmsgint64(&reply_message);		/* sendTime; not used ATM */
+	applyTimestamp = IntegerTimestampToTimestampTz(pq_getmsgint64(&reply_message));
 	replyRequested = pq_getmsgbyte(&reply_message);
 
+	/* Compute the apply lag in milliseconds. */
+	if (applyTimestamp == 0)
+		applyLagUs = -1;
+	else
+#ifdef HAVE_INT64_TIMESTAMP
+		applyLagUs = now - applyTimestamp;
+#else
+		applyLagUs = (now - applyTimestamp) * 1000000;
+#endif
+
 	elog(DEBUG2, "write %X/%X flush %X/%X apply %X/%X%s",
 		 (uint32) (writePtr >> 32), (uint32) writePtr,
 		 (uint32) (flushPtr >> 32), (uint32) flushPtr,
@@ -1583,6 +1597,8 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (applyLagUs >= 0)
+			walsnd->applyLagUs = applyLagUs;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1979,6 +1995,7 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->applyLagUs = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2761,7 +2778,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	9
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2809,6 +2826,7 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		int64		applyLagUs;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2823,6 +2841,7 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		applyLagUs = walsnd->applyLagUs;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2857,6 +2876,23 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 				nulls[5] = true;
 			values[5] = LSNGetDatum(apply);
 
+			if (applyLagUs < 0)
+				nulls[6] = true;
+			else
+			{
+				Interval *applyLagInterval = palloc(sizeof(Interval));
+
+				applyLagInterval->month = 0;
+				applyLagInterval->day = 0;
+#ifdef HAVE_INT64_TIMESTAMP
+				applyLagInterval->time = applyLagUs;
+#else
+				applyLagInterval->time = applyLagUs / 1000000.0;
+#endif
+				nulls[6] = false;
+				values[6] = IntervalPGetDatum(applyLagInterval);
+			}
+
 			/*
 			 * Treat a standby such as a pg_basebackup background process
 			 * which always returns an invalid flush location, as an
@@ -2864,18 +2900,18 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			values[7] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
 			 * informational, not different from priority.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[8] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = CStringGetTextDatum("sync");
+				values[8] = CStringGetTextDatum("sync");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[8] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index c1d6f05..323d640 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -1724,6 +1724,20 @@ GetSQLLocalTimestamp(int32 typmod)
 }
 
 /*
+ * TimestampTzToIntegerTimestamp -- convert a native timestamp to int64 format
+ *
+ * When compiled with --enable-integer-datetimes, this is implemented as a
+ * no-op macro.
+ */
+#ifndef HAVE_INT64_TIMESTAMP
+int64
+TimestampTzToIntegerTimestamp(TimestampTz timestamp)
+{
+	return timestamp * 1000000;
+}
+#endif
+
+/*
  * TimestampDifference -- convert the difference between two timestamps
  *		into integer seconds and microseconds
  *
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index a025117..b1af028 100644
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -1810,6 +1810,17 @@ static struct config_int ConfigureNamesInt[] =
 	},
 
 	{
+		{"replay_lag_sample_interval", PGC_SIGHUP, REPLICATION_STANDBY,
+			gettext_noop("Sets the minimum time between WAL timestamp samples used to estimate replay lag."),
+			NULL,
+			GUC_UNIT_MS
+		},
+		&replay_lag_sample_interval,
+		1 * 1000, -1, INT_MAX / 1000,
+		NULL, NULL, NULL
+	},
+
+	{
 		{"wal_receiver_timeout", PGC_SIGHUP, REPLICATION_STANDBY,
 			gettext_noop("Sets the maximum wait time to receive data from the primary."),
 			NULL,
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index 7f9acfd..bf298f2 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -270,6 +270,8 @@
 					# in milliseconds; 0 disables
 #wal_retrieve_retry_interval = 5s	# time to wait before retrying to
 					# retrieve WAL after a failed attempt
+#replay_lag_sample_interval = 1s	# min time between timestamps recorded
+					# to estimate replay lag; -1 disables replay lag sampling
 
 
 #------------------------------------------------------------------------------
diff --git a/src/bin/pg_basebackup/pg_recvlogical.c b/src/bin/pg_basebackup/pg_recvlogical.c
index cb5f989..9753648 100644
--- a/src/bin/pg_basebackup/pg_recvlogical.c
+++ b/src/bin/pg_basebackup/pg_recvlogical.c
@@ -111,7 +111,7 @@ sendFeedback(PGconn *conn, int64 now, bool force, bool replyRequested)
 	static XLogRecPtr last_written_lsn = InvalidXLogRecPtr;
 	static XLogRecPtr last_fsync_lsn = InvalidXLogRecPtr;
 
-	char		replybuf[1 + 8 + 8 + 8 + 8 + 1];
+	char		replybuf[1 + 8 + 8 + 8 + 8 + 8 + 1];
 	int			len = 0;
 
 	/*
@@ -142,6 +142,8 @@ sendFeedback(PGconn *conn, int64 now, bool force, bool replyRequested)
 	len += 8;
 	fe_sendint64(now, &replybuf[len]);	/* sendTime */
 	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* applyTimestamp */
+	len += 8;
 	replybuf[len] = replyRequested ? 1 : 0;		/* replyRequested */
 	len += 1;
 
diff --git a/src/bin/pg_basebackup/receivelog.c b/src/bin/pg_basebackup/receivelog.c
index 4382e5d..8e89627 100644
--- a/src/bin/pg_basebackup/receivelog.c
+++ b/src/bin/pg_basebackup/receivelog.c
@@ -321,7 +321,7 @@ writeTimeLineHistoryFile(StreamCtl *stream, char *filename, char *content)
 static bool
 sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested)
 {
-	char		replybuf[1 + 8 + 8 + 8 + 8 + 1];
+	char		replybuf[1 + 8 + 8 + 8 + 8 + 8 + 1];
 	int			len = 0;
 
 	replybuf[len] = 'r';
@@ -337,6 +337,8 @@ sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested)
 	len += 8;
 	fe_sendint64(now, &replybuf[len]);	/* sendTime */
 	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* applyTimestamp */
+	len += 8;
 	replybuf[len] = replyRequested ? 1 : 0;		/* replyRequested */
 	len += 1;
 
diff --git a/src/include/access/xlog.h b/src/include/access/xlog.h
index c9f332c..1be2f34 100644
--- a/src/include/access/xlog.h
+++ b/src/include/access/xlog.h
@@ -237,6 +237,9 @@ extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
 extern XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI);
 extern XLogRecPtr GetXLogInsertRecPtr(void);
 extern XLogRecPtr GetXLogWriteRecPtr(void);
+extern void SetXLogReplayTimestamp(TimestampTz timestamp);
+extern void SetXLogReplayTimestampAtLsn(TimestampTz timestamp, XLogRecPtr lsn);
+extern TimestampTz GetXLogReplayTimestamp(XLogRecPtr *lsn);
 extern bool RecoveryIsPaused(void);
 extern void SetRecoveryPause(bool recoveryPause);
 extern TimestampTz GetLatestXTime(void);
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index cd7b909..b565dd8 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2768,7 +2768,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,23,25}" "{o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walreceiver.h b/src/include/replication/walreceiver.h
index 28dc1fc..be25758 100644
--- a/src/include/replication/walreceiver.h
+++ b/src/include/replication/walreceiver.h
@@ -23,6 +23,7 @@
 extern int	wal_receiver_status_interval;
 extern int	wal_receiver_timeout;
 extern bool hot_standby_feedback;
+extern int	replay_lag_sample_interval;
 
 /*
  * MAXCONNINFO: maximum size of a connection string.
@@ -119,6 +120,9 @@ typedef struct
 	 */
 	bool		force_reply;
 
+	/* include the latest replayed timestamp when replying? */
+	bool		force_reply_apply_timestamp;
+
 	/* set true once conninfo is ready to display (obfuscated pwds etc) */
 	bool		ready_to_display;
 
@@ -208,6 +212,6 @@ extern void RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr,
 extern XLogRecPtr GetWalRcvWriteRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI);
 extern int	GetReplicationApplyDelay(void);
 extern int	GetReplicationTransferLatency(void);
-extern void WalRcvForceReply(void);
+extern void WalRcvForceReply(bool sendApplyTimestamp);
 
 #endif   /* _WALRECEIVER_H */
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 7794aa5..4de43e8 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -46,6 +46,7 @@ typedef struct WalSnd
 	XLogRecPtr	write;
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
+	int64		applyLagUs;
 
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
diff --git a/src/include/utils/timestamp.h b/src/include/utils/timestamp.h
index 93b90fe..20517c9 100644
--- a/src/include/utils/timestamp.h
+++ b/src/include/utils/timestamp.h
@@ -233,9 +233,11 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time,
 #ifndef HAVE_INT64_TIMESTAMP
 extern int64 GetCurrentIntegerTimestamp(void);
 extern TimestampTz IntegerTimestampToTimestampTz(int64 timestamp);
+extern int64 TimestampTzToIntegerTimestamp(TimestampTz timestamp);
 #else
 #define GetCurrentIntegerTimestamp()	GetCurrentTimestamp()
 #define IntegerTimestampToTimestampTz(timestamp) (timestamp)
+#define TimestampTzToIntegerTimestamp(timestamp) (timestamp)
 #endif
 
 extern TimestampTz time_t_to_timestamptz(pg_time_t tm);
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 5314b9c..d59956f 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1809,10 +1809,11 @@ pg_stat_replication| SELECT s.pid,
     w.write_location,
     w.flush_location,
     w.replay_location,
+    w.replay_lag,
     w.sync_priority,
     w.sync_state
    FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn)
-     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) ON ((s.pid = w.pid)))
+     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, replay_lag, sync_priority, sync_state) ON ((s.pid = w.pid)))
      LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
 pg_stat_ssl| SELECT s.pid,
     s.ssl,

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 8d7b3bf..b894e31 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -3310,6 +3310,26 @@ ANY <replaceable class="parameter">num_sync</replaceable> ( <replaceable class="
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-replication-lag-sample-interval" xreflabel="replication_lag_sample_interval">
+      <term><varname>replication_lag_sample_interval</varname> (<type>integer</type>)
+      <indexterm>
+       <primary><varname>replication_lag_sample_interval</> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls how often a standby should sample timestamps from upstream to
+        send back to the primary or upstream standby after writing, flushing
+        and replaying WAL.  The default is 1 second.  Units are milliseconds if
+        not specified.  A value of -1 disables the reporting of replication
+        lag.  Estimated lag can be seen in the <link linkend="monitoring-stats-views-table">
+        <literal>pg_stat_replication</></link> view of the upstream server.
+        This parameter can only be set
+        in the <filename>postgresql.conf</> file or on the server command line.
+       </para>
+      </listitem>
+     </varlistentry>
+
      <varlistentry id="guc-hot-standby-feedback" xreflabel="hot_standby_feedback">
       <term><varname>hot_standby_feedback</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 1545f03..a422ac0 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1405,6 +1405,24 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be written on this
+      standby server</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be flushed on this
+      standby server</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be replayed on this
+      standby server</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index f8ffa5c..5a5e5cd 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -82,6 +82,8 @@ extern uint32 bootstrap_data_checksum_version;
 #define PROMOTE_SIGNAL_FILE		"promote"
 #define FALLBACK_PROMOTE_SIGNAL_FILE "fallback_promote"
 
+/* Size of the circular buffer of timestamped LSNs. */
+#define XLOG_TIMESTAMP_BUFFER_SIZE 8192
 
 /* User-settable parameters */
 int			max_wal_size = 64;	/* 1 GB */
@@ -530,6 +532,26 @@ typedef struct XLogCtlInsert
 } XLogCtlInsert;
 
 /*
+ * A sample associating a timestamp with a given xlog position.
+ */
+typedef struct XLogTimestamp
+{
+	TimestampTz	timestamp;
+	XLogRecPtr	lsn;
+} XLogTimestamp;
+
+/*
+ * A circular buffer of LSNs and associated timestamps.  The buffer is empty
+ * when read_head == write_head.
+ */
+typedef struct XLogTimestampBuffer
+{
+	uint32			read_head;
+	uint32			write_head;
+	XLogTimestamp	buffer[XLOG_TIMESTAMP_BUFFER_SIZE];
+} XLogTimestampBuffer;
+
+/*
  * Total shared-memory state for XLOG.
  */
 typedef struct XLogCtlData
@@ -648,6 +670,14 @@ typedef struct XLogCtlData
 	/* timestamp of last COMMIT/ABORT record replayed (or being replayed) */
 	TimestampTz recoveryLastXTime;
 
+	/* timestamp from the most recently applied record associated with a timestamp. */
+	TimestampTz lastReplayedTimestamp;
+
+	/* buffers of timestamps for WAL that is not yet written/flushed/applied. */
+	XLogTimestampBuffer writeTimestamps;
+	XLogTimestampBuffer flushTimestamps;
+	XLogTimestampBuffer applyTimestamps;
+
 	/*
 	 * timestamp of when we started replaying the current chunk of WAL data,
 	 * only relevant for replication or archive recovery
@@ -6006,6 +6036,96 @@ CheckRequiredParameterValues(void)
 }
 
 /*
+ * Read and consume all records from 'buffer' whose position is <= 'lsn'.
+ * Return true if any such records are found, and write the latest timestamp
+ * found into *timestamp.  Write the new read head position into *read_head,
+ * so that the caller can store it with appropriate locking.
+ */
+static bool
+ReadXLogTimestampForLsn(XLogTimestampBuffer *buffer,
+						XLogRecPtr lsn,
+						uint32 *read_head,
+						TimestampTz *timestamp)
+{
+	bool found = false;
+
+	/*
+	 * It's OK to access buffer->read_head without any kind synchronization
+	 * because in all cases the caller is the only process reading from the
+	 * buffer (ie writing to *buffer->read_head).
+	 */
+	*read_head = buffer->read_head;
+
+	/*
+	 * It's OK to access write_head without interlocking because it's an
+	 * aligned 32 bit value which we can read atomically on all supported
+	 * platforms to get some recent value, not a torn/garbage value.
+	 * Furthermore we must see a value that is at least as recent as any WAL
+	 * that we have written/flushed/replayed, because walreceiver calls
+	 * SetXLogTimestampAtLsn before writing.
+	 */
+	while (*read_head != buffer->write_head &&
+		   buffer->buffer[*read_head].lsn <= lsn)
+	{
+		found = true;
+		*timestamp = buffer->buffer[*read_head].timestamp;
+		*read_head = (*read_head + 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+	}
+
+	return found;
+}
+
+/*
+ * Called by the WAL receiver process after it has written up to 'lsn'.
+ * Return true if it has written any LSN location that had an associated
+ * timestamp, and write the timestamp to '*timestamp'.
+ */
+bool
+CheckForWrittenTimestampedLsn(XLogRecPtr lsn, TimestampTz *timestamp)
+{
+	Assert(AmWalReceiverProcess());
+
+	return ReadXLogTimestampForLsn(&XLogCtl->writeTimestamps, lsn,
+								   &XLogCtl->writeTimestamps.read_head,
+								   timestamp);
+}
+
+/*
+ * Called by the WAL receiver process after it has flushed up to 'lsn'.
+ * Return true if it has flushed any LSN location that had an associated
+ * timestamp, and write the timestamp to '*timestamp'.
+ */
+bool
+CheckForFlushedTimestampedLsn(XLogRecPtr lsn, TimestampTz *timestamp)
+{
+	Assert(AmWalReceiverProcess());
+
+	return ReadXLogTimestampForLsn(&XLogCtl->flushTimestamps, lsn,
+								   &XLogCtl->flushTimestamps.read_head,
+								   timestamp);
+}
+
+/*
+ * Called by the startup process after it has replayed up to 'lsn'.  Checks
+ * for timestamps associated with WAL positions that have now been replayed.
+ * If any are found, the latest such timestamp found is written to
+ * '*timestamp'.  Returns the new buffer read head position, which the caller
+ * should write into XLogCtl->timestamps.read_head while holding info_lck.
+ */
+static uint32
+CheckForAppliedTimestampedLsn(XLogRecPtr lsn, TimestampTz *timestamp)
+{
+	uint32 read_head;
+
+	Assert(AmStartupProcess());
+
+	ReadXLogTimestampForLsn(&XLogCtl->applyTimestamps, lsn, &read_head,
+							timestamp);
+
+	return read_head;
+}
+
+/*
  * This must be called ONCE during postmaster or standalone-backend startup
  */
 void
@@ -6824,6 +6944,8 @@ StartupXLOG(void)
 			do
 			{
 				bool		switchedTLI = false;
+				TimestampTz	replayed_timestamp = 0;
+				uint32		timestamp_read_head;
 
 #ifdef WAL_DEBUG
 				if (XLOG_DEBUG ||
@@ -6977,24 +7099,35 @@ StartupXLOG(void)
 				/* Pop the error context stack */
 				error_context_stack = errcallback.previous;
 
+				/* Check if we have replayed a timestamped WAL position */
+				timestamp_read_head =
+					CheckForAppliedTimestampedLsn(EndRecPtr,
+												  &replayed_timestamp);
+
 				/*
-				 * Update lastReplayedEndRecPtr after this record has been
-				 * successfully replayed.
+				 * Update lastReplayedEndRecPtr and lastReplayedTimestamp
+				 * after this record has been successfully replayed.
 				 */
 				SpinLockAcquire(&XLogCtl->info_lck);
 				XLogCtl->lastReplayedEndRecPtr = EndRecPtr;
 				XLogCtl->lastReplayedTLI = ThisTimeLineID;
+				XLogCtl->applyTimestamps.read_head = timestamp_read_head;
+				if (replayed_timestamp != 0)
+					XLogCtl->lastReplayedTimestamp = replayed_timestamp;
 				SpinLockRelease(&XLogCtl->info_lck);
 
 				/*
 				 * If rm_redo called XLogRequestWalReceiverReply, then we wake
 				 * up the receiver so that it notices the updated
-				 * lastReplayedEndRecPtr and sends a reply to the master.
+				 * lastReplayedEndRecPtr and sends a reply to the master.  We
+				 * also wake it if we have replayed a WAL position that has
+				 * an associated timestamp so that the upstream server can
+				 * measure our replay lag.
 				 */
-				if (doRequestWalReceiverReply)
+				if (doRequestWalReceiverReply || replayed_timestamp != 0)
 				{
 					doRequestWalReceiverReply = false;
-					WalRcvForceReply();
+					WalRcvForceReply(replayed_timestamp != 0);
 				}
 
 				/* Remember this record as the last-applied one */
@@ -11809,3 +11942,89 @@ XLogRequestWalReceiverReply(void)
 {
 	doRequestWalReceiverReply = true;
 }
+
+/*
+ * Store an (lsn, timestamp) sample in a timestamp buffer.
+ */
+static void
+StoreXLogTimestampAtLsn(XLogTimestampBuffer *buffer,
+							TimestampTz timestamp, XLogRecPtr lsn)
+{
+
+	uint32 write_head = buffer->write_head;
+	uint32 new_write_head = (write_head + 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+
+	Assert(AmWalReceiverProcess());
+
+	if (new_write_head == buffer->read_head)
+	{
+		/*
+		 * The buffer is full, so we'll rewind and overwrite the most
+		 * recent sample.  Overwriting the most recent sample means that
+		 * if we're not writing/flushing/replaying fast enough and the buffer
+		 * fills up, we'll effectively lower the sampling rate.
+		 */
+		new_write_head = write_head;
+		write_head = (write_head - 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+	}
+
+	buffer->buffer[write_head].lsn = lsn;
+	buffer->buffer[write_head].timestamp = timestamp;
+	buffer->write_head = new_write_head;
+}
+
+/*
+ * Record the timestamp that is associated with a WAL position.
+ *
+ * This is called by walreceiver on standby servers when new messages arrive,
+ * using a timestamp and the latest known WAL position from the upstream
+ * server.  The timestamp will be sent back to the upstream server via
+ * walreceiver when the WAL position is eventually written, flushed and
+ * applied.
+ */
+void
+SetXLogTimestampAtLsn(TimestampTz timestamp, XLogRecPtr lsn)
+{
+	Assert(AmWalReceiverProcess());
+
+	/*
+	 * For the write case we don't need the spinlock because walreceiver
+	 * is both writer and reader.  Currently that is true also of the flush
+	 * case, but in future if that job is given to the WAL writer it should
+	 * be protected by the spinlock below.
+	 */
+	StoreXLogTimestampAtLsn(&XLogCtl->writeTimestamps, timestamp, lsn);
+	StoreXLogTimestampAtLsn(&XLogCtl->flushTimestamps, timestamp, lsn);
+
+	/*
+	 * For the apply cases, the spinlock is needed because the startup process
+	 * is the reader.
+	 */
+	SpinLockAcquire(&XLogCtl->info_lck);
+	StoreXLogTimestampAtLsn(&XLogCtl->applyTimestamps, timestamp, lsn);
+	SpinLockRelease(&XLogCtl->info_lck);
+}
+
+/*
+ * Get the timestamp for the most recently applied WAL record that carried a
+ * timestamp from the upstream server, and also the most recently applied LSN.
+ * (Note that the timestamp and the LSN don't necessarily relate to the same
+ * record.)
+ *
+ * This is similar to GetLatestXTime, except that it is advanced when WAL
+ * positions recorded with SetXLogReplayTimestampAtLsn have been applied,
+ * rather than commit records.
+ */
+TimestampTz
+GetXLogReplayTimestamp(XLogRecPtr *lsn)
+{
+	TimestampTz result;
+
+	SpinLockAcquire(&XLogCtl->info_lck);
+	if (lsn)
+		*lsn = XLogCtl->lastReplayedEndRecPtr;
+	result = XLogCtl->lastReplayedTimestamp;
+	SpinLockRelease(&XLogCtl->info_lck);
+
+	return result;
+}
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 649cef8..2fd63e3 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -685,6 +685,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
index cc3cf7d..8fd7e23 100644
--- a/src/backend/replication/walreceiver.c
+++ b/src/backend/replication/walreceiver.c
@@ -73,6 +73,7 @@
 int			wal_receiver_status_interval;
 int			wal_receiver_timeout;
 bool		hot_standby_feedback;
+int			replication_lag_sample_interval;
 
 /* libpqwalreceiver connection */
 static WalReceiverConn *wrconn = NULL;
@@ -107,6 +108,10 @@ static struct
 	XLogRecPtr	Flush;			/* last byte + 1 flushed in the standby */
 }	LogstreamResult;
 
+/* Latest timestamps for replication lag tracking. */
+static TimestampTz last_write_timestamp;
+static TimestampTz last_flush_timestamp;
+
 static StringInfoData reply_message;
 static StringInfoData incoming_message;
 
@@ -138,7 +143,7 @@ static void WalRcvDie(int code, Datum arg);
 static void XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len);
 static void XLogWalRcvWrite(char *buf, Size nbytes, XLogRecPtr recptr);
 static void XLogWalRcvFlush(bool dying);
-static void XLogWalRcvSendReply(bool force, bool requestReply);
+static void XLogWalRcvSendReply(bool force, bool requestReply, int timestamps);
 static void XLogWalRcvSendHSFeedback(bool immed);
 static void ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime);
 
@@ -148,6 +153,16 @@ static void WalRcvSigUsr1Handler(SIGNAL_ARGS);
 static void WalRcvShutdownHandler(SIGNAL_ARGS);
 static void WalRcvQuickDieHandler(SIGNAL_ARGS);
 
+/*
+ * Which timestamps to include in a reply message.
+ */
+typedef enum XLogReplyTimestamp
+{
+	REPLY_WRITE_TIMESTAMP = 1,
+	REPLY_FLUSH_TIMESTAMP = 2,
+	REPLY_APPLY_TIMESTAMP = 4
+} XLogReplyTimestamp;
+
 
 static void
 ProcessWalRcvInterrupts(void)
@@ -424,6 +439,8 @@ WalReceiverMain(void)
 				len = walrcv_receive(wrconn, &buf, &wait_fd);
 				if (len != 0)
 				{
+					int timestamp = 0;
+
 					/*
 					 * Process the received data, and any subsequent data we
 					 * can read without blocking.
@@ -455,8 +472,17 @@ WalReceiverMain(void)
 						len = walrcv_receive(wrconn, &buf, &wait_fd);
 					}
 
+					/*
+					 * Check if we have written an LSN location for which we
+					 * have a timestamp from the upstream server, for
+					 * replication lag tracking.
+					 */
+					if (CheckForWrittenTimestampedLsn(LogstreamResult.Write,
+													  &last_write_timestamp))
+						timestamp = REPLY_WRITE_TIMESTAMP;
+
 					/* Let the master know that we received some data. */
-					XLogWalRcvSendReply(false, false);
+					XLogWalRcvSendReply(false, false, timestamp);
 
 					/*
 					 * If we've written some records, flush them to disk and
@@ -493,15 +519,20 @@ WalReceiverMain(void)
 					ResetLatch(walrcv->latch);
 					if (walrcv->force_reply)
 					{
+						int timestamps = 0;
+
 						/*
 						 * The recovery process has asked us to send apply
 						 * feedback now.  Make sure the flag is really set to
 						 * false in shared memory before sending the reply, so
 						 * we don't miss a new request for a reply.
 						 */
+						if (walrcv->force_reply_apply_timestamp)
+							timestamps = REPLY_APPLY_TIMESTAMP;
 						walrcv->force_reply = false;
+						walrcv->force_reply_apply_timestamp = false;
 						pg_memory_barrier();
-						XLogWalRcvSendReply(true, false);
+						XLogWalRcvSendReply(true, false, timestamps);
 					}
 				}
 				if (rc & WL_POSTMASTER_DEATH)
@@ -559,7 +590,7 @@ WalReceiverMain(void)
 						}
 					}
 
-					XLogWalRcvSendReply(requestReply, requestReply);
+					XLogWalRcvSendReply(requestReply, requestReply, 0);
 					XLogWalRcvSendHSFeedback(false);
 				}
 			}
@@ -911,7 +942,7 @@ XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len)
 
 				/* If the primary requested a reply, send one immediately */
 				if (replyRequested)
-					XLogWalRcvSendReply(true, false);
+					XLogWalRcvSendReply(true, false, 0);
 				break;
 			}
 		default:
@@ -1074,7 +1105,18 @@ XLogWalRcvFlush(bool dying)
 		/* Also let the master know that we made some progress */
 		if (!dying)
 		{
-			XLogWalRcvSendReply(false, false);
+			/*
+			 * Check if we have just flushed a position for which we have a
+			 * timestamp from the upstream server, for replication lag
+			 * tracking.
+			 */
+			int timestamp = 0;
+
+			if (CheckForFlushedTimestampedLsn(LogstreamResult.Flush,
+											  &last_flush_timestamp))
+				timestamp = REPLY_FLUSH_TIMESTAMP;
+
+			XLogWalRcvSendReply(false, false, timestamp);
 			XLogWalRcvSendHSFeedback(false);
 		}
 	}
@@ -1092,21 +1134,27 @@ XLogWalRcvFlush(bool dying)
  * If 'requestReply' is true, requests the server to reply immediately upon
  * receiving this message. This is used for heartbearts, when approaching
  * wal_receiver_timeout.
+ *
+ * The bitmap 'timestamps' specifies which timestamps should be included, for
+ * replication lag tracking purposes.
  */
 static void
-XLogWalRcvSendReply(bool force, bool requestReply)
+XLogWalRcvSendReply(bool force, bool requestReply, int timestamps)
 {
 	static XLogRecPtr writePtr = 0;
 	static XLogRecPtr flushPtr = 0;
 	XLogRecPtr	applyPtr;
 	static TimestampTz sendTime = 0;
 	TimestampTz now;
+	TimestampTz writeTimestamp = 0;
+	TimestampTz flushTimestamp = 0;
+	TimestampTz applyTimestamp = 0;
 
 	/*
 	 * If the user doesn't want status to be reported to the master, be sure
 	 * to exit before doing anything at all.
 	 */
-	if (!force && wal_receiver_status_interval <= 0)
+	if (!force && timestamps == 0 && wal_receiver_status_interval <= 0)
 		return;
 
 	/* Get current timestamp. */
@@ -1132,7 +1180,41 @@ XLogWalRcvSendReply(bool force, bool requestReply)
 	/* Construct a new message */
 	writePtr = LogstreamResult.Write;
 	flushPtr = LogstreamResult.Flush;
-	applyPtr = GetXLogReplayRecPtr(NULL);
+	applyTimestamp = GetXLogReplayTimestamp(&applyPtr);
+	flushTimestamp = last_flush_timestamp;
+	writeTimestamp = last_write_timestamp;
+
+	/* Decide whether to send timestamps for replay lag estimation. */
+	if (replication_lag_sample_interval != -1)
+	{
+		static TimestampTz lastApplyTimestampSendTime = 0;
+
+		/*
+		 * Only send an apply timestamp if we were explicitly asked to by the
+		 * recovery process or if replay lag sampling is active but the
+		 * recovery process seems to be stuck.
+		 *
+		 * If we haven't heard from the recovery process in a time exceeding
+		 * wal_receiver_status_interval and yet it has not applied the highest
+		 * LSN we've heard about, then we want to resend the last replayed
+		 * timestamp we have; otherwise we zero it out and wait for the
+		 * recovery process to wake us when it has set a new accurate replay
+		 * timestamp.  Note that we can read latestWalEnd without acquiring the
+		 * mutex that protects it because it is only written to by this
+		 * process (walreceiver).
+		 */
+		if (((timestamps & REPLY_APPLY_TIMESTAMP) != 0) ||
+			(WalRcv->latestWalEnd > applyPtr &&
+			 TimestampDifferenceExceeds(lastApplyTimestampSendTime, now,
+										wal_receiver_status_interval * 1000)))
+			lastApplyTimestampSendTime = now;
+		else
+			applyTimestamp = 0;
+		if ((timestamps & REPLY_FLUSH_TIMESTAMP) == 0)
+			flushTimestamp = 0;
+		if ((timestamps & REPLY_WRITE_TIMESTAMP) == 0)
+			writeTimestamp = 0;
+	}
 
 	resetStringInfo(&reply_message);
 	pq_sendbyte(&reply_message, 'r');
@@ -1140,6 +1222,9 @@ XLogWalRcvSendReply(bool force, bool requestReply)
 	pq_sendint64(&reply_message, flushPtr);
 	pq_sendint64(&reply_message, applyPtr);
 	pq_sendint64(&reply_message, GetCurrentIntegerTimestamp());
+	pq_sendint64(&reply_message, TimestampTzToIntegerTimestamp(writeTimestamp));
+	pq_sendint64(&reply_message, TimestampTzToIntegerTimestamp(flushTimestamp));
+	pq_sendint64(&reply_message, TimestampTzToIntegerTimestamp(applyTimestamp));
 	pq_sendbyte(&reply_message, requestReply ? 1 : 0);
 
 	/* Send it */
@@ -1244,18 +1329,41 @@ static void
 ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
 {
 	WalRcvData *walrcv = WalRcv;
-
 	TimestampTz lastMsgReceiptTime = GetCurrentTimestamp();
+	bool newHighWalEnd = false;
+
+	static TimestampTz lastRecordedTimestamp = 0;
 
 	/* Update shared-memory status */
 	SpinLockAcquire(&walrcv->mutex);
 	if (walrcv->latestWalEnd < walEnd)
+	{
 		walrcv->latestWalEndTime = sendTime;
+		newHighWalEnd = true;
+	}
 	walrcv->latestWalEnd = walEnd;
 	walrcv->lastMsgSendTime = sendTime;
 	walrcv->lastMsgReceiptTime = lastMsgReceiptTime;
 	SpinLockRelease(&walrcv->mutex);
 
+	/*
+	 * If replication lag sampling is active, remember the upstream server's
+	 * timestamp at the latest WAL end that it has, unless we've already
+	 * done that too recently or the LSN hasn't advanced.  We'll feed this
+	 * timestamp back once we have written and then flushed this LSN.  It will
+	 * also be fed back to us by the startup process when it eventually
+	 * replays this LSN, so that we can feed it back to the upstream server
+	 * for replay lag tracking purposes.
+	 */
+	if (replication_lag_sample_interval != -1 &&
+		newHighWalEnd &&
+		sendTime > TimestampTzPlusMilliseconds(lastRecordedTimestamp,
+											   replication_lag_sample_interval))
+	{
+		SetXLogTimestampAtLsn(sendTime, walEnd);
+		lastRecordedTimestamp = sendTime;
+	}
+
 	if (log_min_messages <= DEBUG2)
 	{
 		char	   *sendtime;
@@ -1291,12 +1399,14 @@ ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
  * This is called by the startup process whenever interesting xlog records
  * are applied, so that walreceiver can check if it needs to send an apply
  * notification back to the master which may be waiting in a COMMIT with
- * synchronous_commit = remote_apply.
+ * synchronous_commit = remote_apply.  Also used to send periodic messages
+ * which are used to compute pg_stat_replication.replay_lag.
  */
 void
-WalRcvForceReply(void)
+WalRcvForceReply(bool apply_timestamp)
 {
 	WalRcv->force_reply = true;
+	WalRcv->force_reply_apply_timestamp = apply_timestamp;
 	if (WalRcv->latch)
 		SetLatch(WalRcv->latch);
 }
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 5cdb8a0..3fbca0c 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1545,6 +1545,25 @@ PhysicalConfirmReceivedLocation(XLogRecPtr lsn)
 }
 
 /*
+ * Compute the difference between 'timestamp' and 'now' in microseconds.
+ * Return -1 if timestamp is zero.
+ */
+static uint64
+compute_lag(TimestampTz now, TimestampTz timestamp)
+{
+	if (timestamp == 0)
+		return -1;
+	else
+	{
+#ifdef HAVE_INT64_TIMESTAMP
+		return now - timestamp;
+#else
+		return (now - timestamp) * 1000000;
+#endif
+	}
+}
+
+/*
  * Regular reply from standby advising of WAL positions on standby server.
  */
 static void
@@ -1553,15 +1572,30 @@ ProcessStandbyReplyMessage(void)
 	XLogRecPtr	writePtr,
 				flushPtr,
 				applyPtr;
+	int64		writeLagUs,
+				flushLagUs,
+				applyLagUs;
+	TimestampTz writeTimestamp,
+				flushTimestamp,
+				applyTimestamp;
 	bool		replyRequested;
+	TimestampTz now = GetCurrentTimestamp();
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
 	flushPtr = pq_getmsgint64(&reply_message);
 	applyPtr = pq_getmsgint64(&reply_message);
 	(void) pq_getmsgint64(&reply_message);		/* sendTime; not used ATM */
+	writeTimestamp = IntegerTimestampToTimestampTz(pq_getmsgint64(&reply_message));
+	flushTimestamp = IntegerTimestampToTimestampTz(pq_getmsgint64(&reply_message));
+	applyTimestamp = IntegerTimestampToTimestampTz(pq_getmsgint64(&reply_message));
 	replyRequested = pq_getmsgbyte(&reply_message);
 
+	/* Compute the replication lag. */
+	writeLagUs = compute_lag(now, writeTimestamp);
+	flushLagUs = compute_lag(now, flushTimestamp);
+	applyLagUs = compute_lag(now, applyTimestamp);
+
 	elog(DEBUG2, "write %X/%X flush %X/%X apply %X/%X%s",
 		 (uint32) (writePtr >> 32), (uint32) writePtr,
 		 (uint32) (flushPtr >> 32), (uint32) flushPtr,
@@ -1583,6 +1617,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLagUs >= 0)
+			walsnd->writeLagUs = writeLagUs;
+		if (flushLagUs >= 0)
+			walsnd->flushLagUs = flushLagUs;
+		if (applyLagUs >= 0)
+			walsnd->applyLagUs = applyLagUs;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1979,6 +2019,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLagUs = -1;
+			walsnd->flushLagUs = -1;
+			walsnd->applyLagUs = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2753,6 +2796,21 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+lag_as_interval(uint64 lag_us)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+#ifdef HAVE_INT64_TIMESTAMP
+	result->time = lag_us;
+#else
+	result->time = lag_us / 1000000.0;
+#endif
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2761,7 +2819,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2809,6 +2867,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		int64		writeLagUs;
+		int64		flushLagUs;
+		int64		applyLagUs;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2823,6 +2884,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLagUs = walsnd->writeLagUs;
+		flushLagUs = walsnd->flushLagUs;
+		applyLagUs = walsnd->applyLagUs;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2857,6 +2921,21 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 				nulls[5] = true;
 			values[5] = LSNGetDatum(apply);
 
+			if (writeLagUs < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(lag_as_interval(writeLagUs));
+
+			if (flushLagUs < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(lag_as_interval(flushLagUs));
+
+			if (applyLagUs < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(lag_as_interval(applyLagUs));
+
 			/*
 			 * Treat a standby such as a pg_basebackup background process
 			 * which always returns an invalid flush location, as an
@@ -2864,7 +2943,7 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2878,12 +2957,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 545e9e0..90c608d 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -1777,6 +1777,20 @@ GetSQLLocalTimestamp(int32 typmod)
 }
 
 /*
+ * TimestampTzToIntegerTimestamp -- convert a native timestamp to int64 format
+ *
+ * When compiled with --enable-integer-datetimes, this is implemented as a
+ * no-op macro.
+ */
+#ifndef HAVE_INT64_TIMESTAMP
+int64
+TimestampTzToIntegerTimestamp(TimestampTz timestamp)
+{
+	return timestamp * 1000000;
+}
+#endif
+
+/*
  * TimestampDifference -- convert the difference between two timestamps
  *		into integer seconds and microseconds
  *
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index 946ba9e..1adb598 100644
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -1800,6 +1800,17 @@ static struct config_int ConfigureNamesInt[] =
 	},
 
 	{
+		{"replication_lag_sample_interval", PGC_SIGHUP, REPLICATION_STANDBY,
+			gettext_noop("Sets the minimum time between WAL timestamp samples used to estimate replication lag."),
+			NULL,
+			GUC_UNIT_MS
+		},
+		&replication_lag_sample_interval,
+		1 * 1000, -1, INT_MAX / 1000,
+		NULL, NULL, NULL
+	},
+
+	{
 		{"wal_receiver_timeout", PGC_SIGHUP, REPLICATION_STANDBY,
 			gettext_noop("Sets the maximum wait time to receive data from the primary."),
 			NULL,
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index ee8232f..f703e25 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -271,6 +271,8 @@
 					# in milliseconds; 0 disables
 #wal_retrieve_retry_interval = 5s	# time to wait before retrying to
 					# retrieve WAL after a failed attempt
+#replication_lag_sample_interval = 1s	# min time between timestamps recorded
+					# to estimate lag; -1 disables lag sampling
 
 
 #------------------------------------------------------------------------------
diff --git a/src/bin/pg_basebackup/pg_recvlogical.c b/src/bin/pg_basebackup/pg_recvlogical.c
index cb5f989..6feb95d 100644
--- a/src/bin/pg_basebackup/pg_recvlogical.c
+++ b/src/bin/pg_basebackup/pg_recvlogical.c
@@ -111,7 +111,7 @@ sendFeedback(PGconn *conn, int64 now, bool force, bool replyRequested)
 	static XLogRecPtr last_written_lsn = InvalidXLogRecPtr;
 	static XLogRecPtr last_fsync_lsn = InvalidXLogRecPtr;
 
-	char		replybuf[1 + 8 + 8 + 8 + 8 + 1];
+	char		replybuf[1 + 8 + 8 + 8 + 8 + 8 + 8 + 8 + 1];
 	int			len = 0;
 
 	/*
@@ -142,6 +142,12 @@ sendFeedback(PGconn *conn, int64 now, bool force, bool replyRequested)
 	len += 8;
 	fe_sendint64(now, &replybuf[len]);	/* sendTime */
 	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* writeTimestamp */
+	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* flushTimestamp */
+	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* applyTimestamp */
+	len += 8;
 	replybuf[len] = replyRequested ? 1 : 0;		/* replyRequested */
 	len += 1;
 
diff --git a/src/bin/pg_basebackup/receivelog.c b/src/bin/pg_basebackup/receivelog.c
index 568ff17..960e02f 100644
--- a/src/bin/pg_basebackup/receivelog.c
+++ b/src/bin/pg_basebackup/receivelog.c
@@ -321,7 +321,7 @@ writeTimeLineHistoryFile(StreamCtl *stream, char *filename, char *content)
 static bool
 sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested)
 {
-	char		replybuf[1 + 8 + 8 + 8 + 8 + 1];
+	char		replybuf[1 + 8 + 8 + 8 + 8 + 8 + 8 + 8 + 1];
 	int			len = 0;
 
 	replybuf[len] = 'r';
@@ -337,6 +337,12 @@ sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested)
 	len += 8;
 	fe_sendint64(now, &replybuf[len]);	/* sendTime */
 	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* writeTimestamp */
+	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* flushTimestamp */
+	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* applyTimestamp */
+	len += 8;
 	replybuf[len] = replyRequested ? 1 : 0;		/* replyRequested */
 	len += 1;
 
diff --git a/src/include/access/xlog.h b/src/include/access/xlog.h
index 7d21408..ee11cf5 100644
--- a/src/include/access/xlog.h
+++ b/src/include/access/xlog.h
@@ -246,6 +246,12 @@ extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
 extern XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI);
 extern XLogRecPtr GetXLogInsertRecPtr(void);
 extern XLogRecPtr GetXLogWriteRecPtr(void);
+extern void SetXLogTimestampAtLsn(TimestampTz timestamp, XLogRecPtr lsn);
+extern bool CheckForWrittenTimestampedLsn(XLogRecPtr lsn,
+										  TimestampTz *timestamp);
+extern bool CheckForFlushedTimestampedLsn(XLogRecPtr lsn,
+										  TimestampTz *timestamp);
+extern TimestampTz GetXLogReplayTimestamp(XLogRecPtr *lsn);
 extern bool RecoveryIsPaused(void);
 extern void SetRecoveryPause(bool recoveryPause);
 extern TimestampTz GetLatestXTime(void);
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index cd7b909..c6dd6b5 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2768,7 +2768,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walreceiver.h b/src/include/replication/walreceiver.h
index 28dc1fc..41b248f 100644
--- a/src/include/replication/walreceiver.h
+++ b/src/include/replication/walreceiver.h
@@ -23,6 +23,7 @@
 extern int	wal_receiver_status_interval;
 extern int	wal_receiver_timeout;
 extern bool hot_standby_feedback;
+extern int	replication_lag_sample_interval;
 
 /*
  * MAXCONNINFO: maximum size of a connection string.
@@ -119,6 +120,9 @@ typedef struct
 	 */
 	bool		force_reply;
 
+	/* include the latest replayed timestamp when replying? */
+	bool		force_reply_apply_timestamp;
+
 	/* set true once conninfo is ready to display (obfuscated pwds etc) */
 	bool		ready_to_display;
 
@@ -208,6 +212,6 @@ extern void RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr,
 extern XLogRecPtr GetWalRcvWriteRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI);
 extern int	GetReplicationApplyDelay(void);
 extern int	GetReplicationTransferLatency(void);
-extern void WalRcvForceReply(void);
+extern void WalRcvForceReply(bool sendApplyTimestamp);
 
 #endif   /* _WALRECEIVER_H */
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 7794aa5..fb3a03f 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -46,6 +46,9 @@ typedef struct WalSnd
 	XLogRecPtr	write;
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
+	int64		writeLagUs;
+	int64		flushLagUs;
+	int64		applyLagUs;
 
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
diff --git a/src/include/utils/timestamp.h b/src/include/utils/timestamp.h
index 93b90fe..20517c9 100644
--- a/src/include/utils/timestamp.h
+++ b/src/include/utils/timestamp.h
@@ -233,9 +233,11 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time,
 #ifndef HAVE_INT64_TIMESTAMP
 extern int64 GetCurrentIntegerTimestamp(void);
 extern TimestampTz IntegerTimestampToTimestampTz(int64 timestamp);
+extern int64 TimestampTzToIntegerTimestamp(TimestampTz timestamp);
 #else
 #define GetCurrentIntegerTimestamp()	GetCurrentTimestamp()
 #define IntegerTimestampToTimestampTz(timestamp) (timestamp)
+#define TimestampTzToIntegerTimestamp(timestamp) (timestamp)
 #endif
 
 extern TimestampTz time_t_to_timestamptz(pg_time_t tm);
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index e9cfadb..14147c5 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1809,10 +1809,13 @@ pg_stat_replication| SELECT s.pid,
     w.write_location,
     w.flush_location,
     w.replay_location,
+    w.write_lag,
+    w.flush_lag,
+    w.replay_lag,
     w.sync_priority,
     w.sync_state
    FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn)
-     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) ON ((s.pid = w.pid)))
+     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, write_lag, flush_lag, replay_lag, sync_priority, sync_state) ON ((s.pid = w.pid)))
      LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
 pg_stat_ssl| SELECT s.pid,
     s.ssl,

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 8d7b3bf..b894e31 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -3310,6 +3310,26 @@ ANY <replaceable class="parameter">num_sync</replaceable> ( <replaceable class="
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-replication-lag-sample-interval" xreflabel="replication_lag_sample_interval">
+      <term><varname>replication_lag_sample_interval</varname> (<type>integer</type>)
+      <indexterm>
+       <primary><varname>replication_lag_sample_interval</> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls how often a standby should sample timestamps from upstream to
+        send back to the primary or upstream standby after writing, flushing
+        and replaying WAL.  The default is 1 second.  Units are milliseconds if
+        not specified.  A value of -1 disables the reporting of replication
+        lag.  Estimated lag can be seen in the <link linkend="monitoring-stats-views-table">
+        <literal>pg_stat_replication</></link> view of the upstream server.
+        This parameter can only be set
+        in the <filename>postgresql.conf</> file or on the server command line.
+       </para>
+      </listitem>
+     </varlistentry>
+
      <varlistentry id="guc-hot-standby-feedback" xreflabel="hot_standby_feedback">
       <term><varname>hot_standby_feedback</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 1545f03..a422ac0 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1405,6 +1405,24 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be written on this
+      standby server</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be flushed on this
+      standby server</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be replayed on this
+      standby server</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index f8ffa5c..7e7312f 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -82,6 +82,8 @@ extern uint32 bootstrap_data_checksum_version;
 #define PROMOTE_SIGNAL_FILE		"promote"
 #define FALLBACK_PROMOTE_SIGNAL_FILE "fallback_promote"
 
+/* Size of the circular buffer of timestamped LSNs. */
+#define XLOG_TIMESTAMP_BUFFER_SIZE 8192
 
 /* User-settable parameters */
 int			max_wal_size = 64;	/* 1 GB */
@@ -530,6 +532,26 @@ typedef struct XLogCtlInsert
 } XLogCtlInsert;
 
 /*
+ * A sample associating a timestamp with a given xlog position.
+ */
+typedef struct XLogTimestamp
+{
+	TimestampTz	timestamp;
+	XLogRecPtr	lsn;
+} XLogTimestamp;
+
+/*
+ * A circular buffer of LSNs and associated timestamps.  The buffer is empty
+ * when read_head == write_head.
+ */
+typedef struct XLogTimestampBuffer
+{
+	uint32			read_head;
+	uint32			write_head;
+	XLogTimestamp	buffer[XLOG_TIMESTAMP_BUFFER_SIZE];
+} XLogTimestampBuffer;
+
+/*
  * Total shared-memory state for XLOG.
  */
 typedef struct XLogCtlData
@@ -648,6 +670,14 @@ typedef struct XLogCtlData
 	/* timestamp of last COMMIT/ABORT record replayed (or being replayed) */
 	TimestampTz recoveryLastXTime;
 
+	/* timestamp from the most recently applied record associated with a timestamp. */
+	TimestampTz lastReplayedTimestamp;
+
+	/* buffers of timestamps for WAL that is not yet written/flushed/applied. */
+	XLogTimestampBuffer writeTimestamps;
+	XLogTimestampBuffer flushTimestamps;
+	XLogTimestampBuffer applyTimestamps;
+
 	/*
 	 * timestamp of when we started replaying the current chunk of WAL data,
 	 * only relevant for replication or archive recovery
@@ -6006,6 +6036,96 @@ CheckRequiredParameterValues(void)
 }
 
 /*
+ * Read and consume all records from 'buffer' whose position is <= 'lsn'.
+ * Return true if any such records are found, and write the latest timestamp
+ * found into *timestamp.  Write the new read head position into *read_head,
+ * so that the caller can store it with appropriate locking.
+ */
+static bool
+ReadXLogTimestampForLsn(XLogTimestampBuffer *buffer,
+						XLogRecPtr lsn,
+						uint32 *read_head,
+						TimestampTz *timestamp)
+{
+	bool found = false;
+
+	/*
+	 * It's OK to access buffer->read_head without any kind synchronization
+	 * because in all cases the caller is the only process reading from the
+	 * buffer (ie writing to *buffer->read_head).
+	 */
+	*read_head = buffer->read_head;
+
+	/*
+	 * It's OK to access write_head without interlocking because it's an
+	 * aligned 32 bit value which we can read atomically on all supported
+	 * platforms to get some recent value, not a torn/garbage value.
+	 * Furthermore we must see a value that is at least as recent as any WAL
+	 * that we have written/flushed/replayed, because walreceiver calls
+	 * SetXLogTimestampAtLsn before writing.
+	 */
+	while (*read_head != buffer->write_head &&
+		   buffer->buffer[*read_head].lsn <= lsn)
+	{
+		found = true;
+		*timestamp = buffer->buffer[*read_head].timestamp;
+		*read_head = (*read_head + 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+	}
+
+	return found;
+}
+
+/*
+ * Called by the WAL receiver process after it has written up to 'lsn'.
+ * Return true if it has written any LSN location that had an associated
+ * timestamp, and write the timestamp to '*timestamp'.
+ */
+bool
+CheckForWrittenTimestampedLsn(XLogRecPtr lsn, TimestampTz *timestamp)
+{
+	Assert(AmWalReceiverProcess());
+
+	return ReadXLogTimestampForLsn(&XLogCtl->writeTimestamps, lsn,
+								   &XLogCtl->writeTimestamps.read_head,
+								   timestamp);
+}
+
+/*
+ * Called by the WAL receiver process after it has flushed up to 'lsn'.
+ * Return true if it has flushed any LSN location that had an associated
+ * timestamp, and write the timestamp to '*timestamp'.
+ */
+bool
+CheckForFlushedTimestampedLsn(XLogRecPtr lsn, TimestampTz *timestamp)
+{
+	Assert(AmWalReceiverProcess());
+
+	return ReadXLogTimestampForLsn(&XLogCtl->flushTimestamps, lsn,
+								   &XLogCtl->flushTimestamps.read_head,
+								   timestamp);
+}
+
+/*
+ * Called by the startup process after it has replayed up to 'lsn'.  Checks
+ * for timestamps associated with WAL positions that have now been replayed.
+ * If any are found, the latest such timestamp found is written to
+ * '*timestamp'.  Returns the new buffer read head position, which the caller
+ * should write into XLogCtl->timestamps.read_head while holding info_lck.
+ */
+static uint32
+CheckForAppliedTimestampedLsn(XLogRecPtr lsn, TimestampTz *timestamp)
+{
+	uint32 read_head;
+
+	Assert(AmStartupProcess());
+
+	ReadXLogTimestampForLsn(&XLogCtl->applyTimestamps, lsn, &read_head,
+							timestamp);
+
+	return read_head;
+}
+
+/*
  * This must be called ONCE during postmaster or standalone-backend startup
  */
 void
@@ -6824,6 +6944,8 @@ StartupXLOG(void)
 			do
 			{
 				bool		switchedTLI = false;
+				TimestampTz	replayed_timestamp = 0;
+				uint32		timestamp_read_head;
 
 #ifdef WAL_DEBUG
 				if (XLOG_DEBUG ||
@@ -6977,24 +7099,35 @@ StartupXLOG(void)
 				/* Pop the error context stack */
 				error_context_stack = errcallback.previous;
 
+				/* Check if we have replayed a timestamped WAL position */
+				timestamp_read_head =
+					CheckForAppliedTimestampedLsn(EndRecPtr,
+												  &replayed_timestamp);
+
 				/*
-				 * Update lastReplayedEndRecPtr after this record has been
-				 * successfully replayed.
+				 * Update lastReplayedEndRecPtr and lastReplayedTimestamp
+				 * after this record has been successfully replayed.
 				 */
 				SpinLockAcquire(&XLogCtl->info_lck);
 				XLogCtl->lastReplayedEndRecPtr = EndRecPtr;
 				XLogCtl->lastReplayedTLI = ThisTimeLineID;
+				XLogCtl->applyTimestamps.read_head = timestamp_read_head;
+				if (replayed_timestamp != 0)
+					XLogCtl->lastReplayedTimestamp = replayed_timestamp;
 				SpinLockRelease(&XLogCtl->info_lck);
 
 				/*
 				 * If rm_redo called XLogRequestWalReceiverReply, then we wake
 				 * up the receiver so that it notices the updated
-				 * lastReplayedEndRecPtr and sends a reply to the master.
+				 * lastReplayedEndRecPtr and sends a reply to the master.  We
+				 * also wake it if we have replayed a WAL position that has
+				 * an associated timestamp so that the upstream server can
+				 * measure our replay lag.
 				 */
-				if (doRequestWalReceiverReply)
+				if (doRequestWalReceiverReply || replayed_timestamp != 0)
 				{
 					doRequestWalReceiverReply = false;
-					WalRcvForceReply();
+					WalRcvForceReply(replayed_timestamp != 0);
 				}
 
 				/* Remember this record as the last-applied one */
@@ -11809,3 +11942,106 @@ XLogRequestWalReceiverReply(void)
 {
 	doRequestWalReceiverReply = true;
 }
+
+/*
+ * Store an (lsn, timestamp) sample in a timestamp buffer.
+ */
+static void
+StoreXLogTimestampAtLsn(XLogTimestampBuffer *buffer,
+							TimestampTz timestamp, XLogRecPtr lsn)
+{
+
+	uint32 write_head = buffer->write_head;
+	uint32 new_write_head = (write_head + 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+
+	Assert(AmWalReceiverProcess());
+
+	if (new_write_head == buffer->read_head)
+	{
+		/*
+		 * The buffer is full, so we'll rewind and overwrite the most
+		 * recent sample.  Overwriting the most recent sample means that
+		 * if we're not writing/flushing/replaying fast enough and the buffer
+		 * fills up, we'll effectively lower the sampling rate.
+		 */
+		new_write_head = write_head;
+		write_head = (write_head - 1) % XLOG_TIMESTAMP_BUFFER_SIZE;
+	}
+
+	buffer->buffer[write_head].lsn = lsn;
+	buffer->buffer[write_head].timestamp = timestamp;
+	buffer->write_head = new_write_head;
+}
+
+/*
+ * Record the timestamp that is associated with a WAL position.
+ *
+ * This is called by walreceiver on standby servers when new messages arrive,
+ * using a timestamp and the latest known WAL position from the upstream
+ * server.  The timestamp will be sent back to the upstream server via
+ * walreceiver when the WAL position is eventually written, flushed and
+ * applied.
+ */
+void
+SetXLogTimestampAtLsn(TimestampTz timestamp, XLogRecPtr lsn)
+{
+	bool applied_end = false;
+	static TimestampTz last_timestamp;
+	static XLogRecPtr last_lsn;
+
+	Assert(AmWalReceiverProcess());
+	Assert(replication_lag_sample_interval >= 0);
+
+	SpinLockAcquire(&XLogCtl->info_lck);
+
+	/*
+	 * Check if we're fully applied, so we can avoid recording samples in that
+	 * case.  There is effectively no replay lag, and we don't want to report
+	 * bogus lag after a period of idleness.
+	 */
+	if (lsn == XLogCtl->lastReplayedEndRecPtr)
+		applied_end = true;
+
+	/*
+	 * Record this timestamp/LSN pair, if the LSN has moved since last time
+	 * and we haven't recorded a sample too recently.
+	 */
+	if (!applied_end &&
+		lsn > last_lsn &&
+		timestamp > TimestampTzPlusMilliseconds(last_timestamp,
+											replication_lag_sample_interval))
+	{
+		StoreXLogTimestampAtLsn(&XLogCtl->applyTimestamps, timestamp, lsn);
+		StoreXLogTimestampAtLsn(&XLogCtl->writeTimestamps, timestamp, lsn);
+		StoreXLogTimestampAtLsn(&XLogCtl->flushTimestamps, timestamp, lsn);
+
+		last_timestamp = timestamp;
+		last_lsn = lsn;
+	}
+
+	SpinLockRelease(&XLogCtl->info_lck);
+}
+
+/*
+ * Get the timestamp for the most recently applied WAL record that carried a
+ * timestamp from the upstream server, and also the most recently applied LSN.
+ * (Note that the timestamp and the LSN don't necessarily relate to the same
+ * record.)
+ *
+ * This is similar to GetLatestXTime, except that it is advanced when WAL
+ * positions recorded with SetXLogReplayTimestampAtLsn have been applied,
+ * rather than commit records.
+ */
+TimestampTz
+GetXLogReplayTimestamp(XLogRecPtr *lsn)
+{
+	TimestampTz result;
+
+	SpinLockAcquire(&XLogCtl->info_lck);
+	if (lsn)
+		*lsn = XLogCtl->lastReplayedEndRecPtr;
+	result = XLogCtl->lastReplayedTimestamp;
+	SpinLockRelease(&XLogCtl->info_lck);
+
+	return result;
+}
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 649cef8..2fd63e3 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -685,6 +685,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
index cc3cf7d..621aa24 100644
--- a/src/backend/replication/walreceiver.c
+++ b/src/backend/replication/walreceiver.c
@@ -73,6 +73,7 @@
 int			wal_receiver_status_interval;
 int			wal_receiver_timeout;
 bool		hot_standby_feedback;
+int			replication_lag_sample_interval;
 
 /* libpqwalreceiver connection */
 static WalReceiverConn *wrconn = NULL;
@@ -107,6 +108,10 @@ static struct
 	XLogRecPtr	Flush;			/* last byte + 1 flushed in the standby */
 }	LogstreamResult;
 
+/* Latest timestamps for replication lag tracking. */
+static TimestampTz last_write_timestamp;
+static TimestampTz last_flush_timestamp;
+
 static StringInfoData reply_message;
 static StringInfoData incoming_message;
 
@@ -138,7 +143,7 @@ static void WalRcvDie(int code, Datum arg);
 static void XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len);
 static void XLogWalRcvWrite(char *buf, Size nbytes, XLogRecPtr recptr);
 static void XLogWalRcvFlush(bool dying);
-static void XLogWalRcvSendReply(bool force, bool requestReply);
+static void XLogWalRcvSendReply(bool force, bool requestReply, int timestamps);
 static void XLogWalRcvSendHSFeedback(bool immed);
 static void ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime);
 
@@ -148,6 +153,16 @@ static void WalRcvSigUsr1Handler(SIGNAL_ARGS);
 static void WalRcvShutdownHandler(SIGNAL_ARGS);
 static void WalRcvQuickDieHandler(SIGNAL_ARGS);
 
+/*
+ * Which timestamps to include in a reply message.
+ */
+typedef enum XLogReplyTimestamp
+{
+	REPLY_WRITE_TIMESTAMP = 1,
+	REPLY_FLUSH_TIMESTAMP = 2,
+	REPLY_APPLY_TIMESTAMP = 4
+} XLogReplyTimestamp;
+
 
 static void
 ProcessWalRcvInterrupts(void)
@@ -424,6 +439,8 @@ WalReceiverMain(void)
 				len = walrcv_receive(wrconn, &buf, &wait_fd);
 				if (len != 0)
 				{
+					int timestamp = 0;
+
 					/*
 					 * Process the received data, and any subsequent data we
 					 * can read without blocking.
@@ -455,8 +472,17 @@ WalReceiverMain(void)
 						len = walrcv_receive(wrconn, &buf, &wait_fd);
 					}
 
+					/*
+					 * Check if we have written an LSN location for which we
+					 * have a timestamp from the upstream server, for
+					 * replication lag tracking.
+					 */
+					if (CheckForWrittenTimestampedLsn(LogstreamResult.Write,
+													  &last_write_timestamp))
+						timestamp = REPLY_WRITE_TIMESTAMP;
+
 					/* Let the master know that we received some data. */
-					XLogWalRcvSendReply(false, false);
+					XLogWalRcvSendReply(false, false, timestamp);
 
 					/*
 					 * If we've written some records, flush them to disk and
@@ -493,15 +519,20 @@ WalReceiverMain(void)
 					ResetLatch(walrcv->latch);
 					if (walrcv->force_reply)
 					{
+						int timestamps = 0;
+
 						/*
 						 * The recovery process has asked us to send apply
 						 * feedback now.  Make sure the flag is really set to
 						 * false in shared memory before sending the reply, so
 						 * we don't miss a new request for a reply.
 						 */
+						if (walrcv->force_reply_apply_timestamp)
+							timestamps = REPLY_APPLY_TIMESTAMP;
 						walrcv->force_reply = false;
+						walrcv->force_reply_apply_timestamp = false;
 						pg_memory_barrier();
-						XLogWalRcvSendReply(true, false);
+						XLogWalRcvSendReply(true, false, timestamps);
 					}
 				}
 				if (rc & WL_POSTMASTER_DEATH)
@@ -559,7 +590,7 @@ WalReceiverMain(void)
 						}
 					}
 
-					XLogWalRcvSendReply(requestReply, requestReply);
+					XLogWalRcvSendReply(requestReply, requestReply, 0);
 					XLogWalRcvSendHSFeedback(false);
 				}
 			}
@@ -911,7 +942,7 @@ XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len)
 
 				/* If the primary requested a reply, send one immediately */
 				if (replyRequested)
-					XLogWalRcvSendReply(true, false);
+					XLogWalRcvSendReply(true, false, 0);
 				break;
 			}
 		default:
@@ -1074,7 +1105,18 @@ XLogWalRcvFlush(bool dying)
 		/* Also let the master know that we made some progress */
 		if (!dying)
 		{
-			XLogWalRcvSendReply(false, false);
+			/*
+			 * Check if we have just flushed a position for which we have a
+			 * timestamp from the upstream server, for replication lag
+			 * tracking.
+			 */
+			int timestamp = 0;
+
+			if (CheckForFlushedTimestampedLsn(LogstreamResult.Flush,
+											  &last_flush_timestamp))
+				timestamp = REPLY_FLUSH_TIMESTAMP;
+
+			XLogWalRcvSendReply(false, false, timestamp);
 			XLogWalRcvSendHSFeedback(false);
 		}
 	}
@@ -1092,21 +1134,27 @@ XLogWalRcvFlush(bool dying)
  * If 'requestReply' is true, requests the server to reply immediately upon
  * receiving this message. This is used for heartbearts, when approaching
  * wal_receiver_timeout.
+ *
+ * The bitmap 'timestamps' specifies which timestamps should be included, for
+ * replication lag tracking purposes.
  */
 static void
-XLogWalRcvSendReply(bool force, bool requestReply)
+XLogWalRcvSendReply(bool force, bool requestReply, int timestamps)
 {
 	static XLogRecPtr writePtr = 0;
 	static XLogRecPtr flushPtr = 0;
 	XLogRecPtr	applyPtr;
 	static TimestampTz sendTime = 0;
 	TimestampTz now;
+	TimestampTz writeTimestamp = 0;
+	TimestampTz flushTimestamp = 0;
+	TimestampTz applyTimestamp = 0;
 
 	/*
 	 * If the user doesn't want status to be reported to the master, be sure
 	 * to exit before doing anything at all.
 	 */
-	if (!force && wal_receiver_status_interval <= 0)
+	if (!force && timestamps == 0 && wal_receiver_status_interval <= 0)
 		return;
 
 	/* Get current timestamp. */
@@ -1132,7 +1180,41 @@ XLogWalRcvSendReply(bool force, bool requestReply)
 	/* Construct a new message */
 	writePtr = LogstreamResult.Write;
 	flushPtr = LogstreamResult.Flush;
-	applyPtr = GetXLogReplayRecPtr(NULL);
+	applyTimestamp = GetXLogReplayTimestamp(&applyPtr);
+	flushTimestamp = last_flush_timestamp;
+	writeTimestamp = last_write_timestamp;
+
+	/* Decide whether to send timestamps for replay lag estimation. */
+	if (replication_lag_sample_interval != -1)
+	{
+		static TimestampTz lastApplyTimestampSendTime = 0;
+
+		/*
+		 * Only send an apply timestamp if we were explicitly asked to by the
+		 * recovery process or if replay lag sampling is active but the
+		 * recovery process seems to be stuck.
+		 *
+		 * If we haven't heard from the recovery process in a time exceeding
+		 * wal_receiver_status_interval and yet it has not applied the highest
+		 * LSN we've heard about, then we want to resend the last replayed
+		 * timestamp we have; otherwise we zero it out and wait for the
+		 * recovery process to wake us when it has set a new accurate replay
+		 * timestamp.  Note that we can read latestWalEnd without acquiring the
+		 * mutex that protects it because it is only written to by this
+		 * process (walreceiver).
+		 */
+		if (((timestamps & REPLY_APPLY_TIMESTAMP) != 0) ||
+			(WalRcv->latestWalEnd > applyPtr &&
+			 TimestampDifferenceExceeds(lastApplyTimestampSendTime, now,
+										wal_receiver_status_interval * 1000)))
+			lastApplyTimestampSendTime = now;
+		else
+			applyTimestamp = 0;
+		if ((timestamps & REPLY_FLUSH_TIMESTAMP) == 0)
+			flushTimestamp = 0;
+		if ((timestamps & REPLY_WRITE_TIMESTAMP) == 0)
+			writeTimestamp = 0;
+	}
 
 	resetStringInfo(&reply_message);
 	pq_sendbyte(&reply_message, 'r');
@@ -1140,6 +1222,9 @@ XLogWalRcvSendReply(bool force, bool requestReply)
 	pq_sendint64(&reply_message, flushPtr);
 	pq_sendint64(&reply_message, applyPtr);
 	pq_sendint64(&reply_message, GetCurrentIntegerTimestamp());
+	pq_sendint64(&reply_message, TimestampTzToIntegerTimestamp(writeTimestamp));
+	pq_sendint64(&reply_message, TimestampTzToIntegerTimestamp(flushTimestamp));
+	pq_sendint64(&reply_message, TimestampTzToIntegerTimestamp(applyTimestamp));
 	pq_sendbyte(&reply_message, requestReply ? 1 : 0);
 
 	/* Send it */
@@ -1244,7 +1329,6 @@ static void
 ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
 {
 	WalRcvData *walrcv = WalRcv;
-
 	TimestampTz lastMsgReceiptTime = GetCurrentTimestamp();
 
 	/* Update shared-memory status */
@@ -1256,6 +1340,16 @@ ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
 	walrcv->lastMsgReceiptTime = lastMsgReceiptTime;
 	SpinLockRelease(&walrcv->mutex);
 
+	/*
+	 * If replication lag sampling is active, remember the upstream server's
+	 * timestamp at the latest WAL end that it has.  We'll be able to retrieve
+	 * this timestamp once we have written, flushed and finally applied this
+	 * LSN, so that we can report it to the upstream server for lag tracking
+	 * purposes.
+	 */
+	if (replication_lag_sample_interval != -1)
+		SetXLogTimestampAtLsn(sendTime, walEnd);
+
 	if (log_min_messages <= DEBUG2)
 	{
 		char	   *sendtime;
@@ -1291,12 +1385,14 @@ ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime)
  * This is called by the startup process whenever interesting xlog records
  * are applied, so that walreceiver can check if it needs to send an apply
  * notification back to the master which may be waiting in a COMMIT with
- * synchronous_commit = remote_apply.
+ * synchronous_commit = remote_apply.  Also used to send periodic messages
+ * which are used to compute pg_stat_replication.replay_lag.
  */
 void
-WalRcvForceReply(void)
+WalRcvForceReply(bool apply_timestamp)
 {
 	WalRcv->force_reply = true;
+	WalRcv->force_reply_apply_timestamp = apply_timestamp;
 	if (WalRcv->latch)
 		SetLatch(WalRcv->latch);
 }
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 5cdb8a0..3fbca0c 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1545,6 +1545,25 @@ PhysicalConfirmReceivedLocation(XLogRecPtr lsn)
 }
 
 /*
+ * Compute the difference between 'timestamp' and 'now' in microseconds.
+ * Return -1 if timestamp is zero.
+ */
+static uint64
+compute_lag(TimestampTz now, TimestampTz timestamp)
+{
+	if (timestamp == 0)
+		return -1;
+	else
+	{
+#ifdef HAVE_INT64_TIMESTAMP
+		return now - timestamp;
+#else
+		return (now - timestamp) * 1000000;
+#endif
+	}
+}
+
+/*
  * Regular reply from standby advising of WAL positions on standby server.
  */
 static void
@@ -1553,15 +1572,30 @@ ProcessStandbyReplyMessage(void)
 	XLogRecPtr	writePtr,
 				flushPtr,
 				applyPtr;
+	int64		writeLagUs,
+				flushLagUs,
+				applyLagUs;
+	TimestampTz writeTimestamp,
+				flushTimestamp,
+				applyTimestamp;
 	bool		replyRequested;
+	TimestampTz now = GetCurrentTimestamp();
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
 	flushPtr = pq_getmsgint64(&reply_message);
 	applyPtr = pq_getmsgint64(&reply_message);
 	(void) pq_getmsgint64(&reply_message);		/* sendTime; not used ATM */
+	writeTimestamp = IntegerTimestampToTimestampTz(pq_getmsgint64(&reply_message));
+	flushTimestamp = IntegerTimestampToTimestampTz(pq_getmsgint64(&reply_message));
+	applyTimestamp = IntegerTimestampToTimestampTz(pq_getmsgint64(&reply_message));
 	replyRequested = pq_getmsgbyte(&reply_message);
 
+	/* Compute the replication lag. */
+	writeLagUs = compute_lag(now, writeTimestamp);
+	flushLagUs = compute_lag(now, flushTimestamp);
+	applyLagUs = compute_lag(now, applyTimestamp);
+
 	elog(DEBUG2, "write %X/%X flush %X/%X apply %X/%X%s",
 		 (uint32) (writePtr >> 32), (uint32) writePtr,
 		 (uint32) (flushPtr >> 32), (uint32) flushPtr,
@@ -1583,6 +1617,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLagUs >= 0)
+			walsnd->writeLagUs = writeLagUs;
+		if (flushLagUs >= 0)
+			walsnd->flushLagUs = flushLagUs;
+		if (applyLagUs >= 0)
+			walsnd->applyLagUs = applyLagUs;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1979,6 +2019,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLagUs = -1;
+			walsnd->flushLagUs = -1;
+			walsnd->applyLagUs = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2753,6 +2796,21 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+lag_as_interval(uint64 lag_us)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+#ifdef HAVE_INT64_TIMESTAMP
+	result->time = lag_us;
+#else
+	result->time = lag_us / 1000000.0;
+#endif
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2761,7 +2819,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2809,6 +2867,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		int64		writeLagUs;
+		int64		flushLagUs;
+		int64		applyLagUs;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2823,6 +2884,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLagUs = walsnd->writeLagUs;
+		flushLagUs = walsnd->flushLagUs;
+		applyLagUs = walsnd->applyLagUs;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2857,6 +2921,21 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 				nulls[5] = true;
 			values[5] = LSNGetDatum(apply);
 
+			if (writeLagUs < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(lag_as_interval(writeLagUs));
+
+			if (flushLagUs < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(lag_as_interval(flushLagUs));
+
+			if (applyLagUs < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(lag_as_interval(applyLagUs));
+
 			/*
 			 * Treat a standby such as a pg_basebackup background process
 			 * which always returns an invalid flush location, as an
@@ -2864,7 +2943,7 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2878,12 +2957,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 545e9e0..90c608d 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -1777,6 +1777,20 @@ GetSQLLocalTimestamp(int32 typmod)
 }
 
 /*
+ * TimestampTzToIntegerTimestamp -- convert a native timestamp to int64 format
+ *
+ * When compiled with --enable-integer-datetimes, this is implemented as a
+ * no-op macro.
+ */
+#ifndef HAVE_INT64_TIMESTAMP
+int64
+TimestampTzToIntegerTimestamp(TimestampTz timestamp)
+{
+	return timestamp * 1000000;
+}
+#endif
+
+/*
  * TimestampDifference -- convert the difference between two timestamps
  *		into integer seconds and microseconds
  *
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index 946ba9e..1adb598 100644
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -1800,6 +1800,17 @@ static struct config_int ConfigureNamesInt[] =
 	},
 
 	{
+		{"replication_lag_sample_interval", PGC_SIGHUP, REPLICATION_STANDBY,
+			gettext_noop("Sets the minimum time between WAL timestamp samples used to estimate replication lag."),
+			NULL,
+			GUC_UNIT_MS
+		},
+		&replication_lag_sample_interval,
+		1 * 1000, -1, INT_MAX / 1000,
+		NULL, NULL, NULL
+	},
+
+	{
 		{"wal_receiver_timeout", PGC_SIGHUP, REPLICATION_STANDBY,
 			gettext_noop("Sets the maximum wait time to receive data from the primary."),
 			NULL,
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index ee8232f..f703e25 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -271,6 +271,8 @@
 					# in milliseconds; 0 disables
 #wal_retrieve_retry_interval = 5s	# time to wait before retrying to
 					# retrieve WAL after a failed attempt
+#replication_lag_sample_interval = 1s	# min time between timestamps recorded
+					# to estimate lag; -1 disables lag sampling
 
 
 #------------------------------------------------------------------------------
diff --git a/src/bin/pg_basebackup/pg_recvlogical.c b/src/bin/pg_basebackup/pg_recvlogical.c
index cb5f989..6feb95d 100644
--- a/src/bin/pg_basebackup/pg_recvlogical.c
+++ b/src/bin/pg_basebackup/pg_recvlogical.c
@@ -111,7 +111,7 @@ sendFeedback(PGconn *conn, int64 now, bool force, bool replyRequested)
 	static XLogRecPtr last_written_lsn = InvalidXLogRecPtr;
 	static XLogRecPtr last_fsync_lsn = InvalidXLogRecPtr;
 
-	char		replybuf[1 + 8 + 8 + 8 + 8 + 1];
+	char		replybuf[1 + 8 + 8 + 8 + 8 + 8 + 8 + 8 + 1];
 	int			len = 0;
 
 	/*
@@ -142,6 +142,12 @@ sendFeedback(PGconn *conn, int64 now, bool force, bool replyRequested)
 	len += 8;
 	fe_sendint64(now, &replybuf[len]);	/* sendTime */
 	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* writeTimestamp */
+	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* flushTimestamp */
+	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* applyTimestamp */
+	len += 8;
 	replybuf[len] = replyRequested ? 1 : 0;		/* replyRequested */
 	len += 1;
 
diff --git a/src/bin/pg_basebackup/receivelog.c b/src/bin/pg_basebackup/receivelog.c
index 568ff17..960e02f 100644
--- a/src/bin/pg_basebackup/receivelog.c
+++ b/src/bin/pg_basebackup/receivelog.c
@@ -321,7 +321,7 @@ writeTimeLineHistoryFile(StreamCtl *stream, char *filename, char *content)
 static bool
 sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested)
 {
-	char		replybuf[1 + 8 + 8 + 8 + 8 + 1];
+	char		replybuf[1 + 8 + 8 + 8 + 8 + 8 + 8 + 8 + 1];
 	int			len = 0;
 
 	replybuf[len] = 'r';
@@ -337,6 +337,12 @@ sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested)
 	len += 8;
 	fe_sendint64(now, &replybuf[len]);	/* sendTime */
 	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* writeTimestamp */
+	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* flushTimestamp */
+	len += 8;
+	fe_sendint64(0, &replybuf[len]);	/* applyTimestamp */
+	len += 8;
 	replybuf[len] = replyRequested ? 1 : 0;		/* replyRequested */
 	len += 1;
 
diff --git a/src/include/access/xlog.h b/src/include/access/xlog.h
index 7d21408..ee11cf5 100644
--- a/src/include/access/xlog.h
+++ b/src/include/access/xlog.h
@@ -246,6 +246,12 @@ extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
 extern XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI);
 extern XLogRecPtr GetXLogInsertRecPtr(void);
 extern XLogRecPtr GetXLogWriteRecPtr(void);
+extern void SetXLogTimestampAtLsn(TimestampTz timestamp, XLogRecPtr lsn);
+extern bool CheckForWrittenTimestampedLsn(XLogRecPtr lsn,
+										  TimestampTz *timestamp);
+extern bool CheckForFlushedTimestampedLsn(XLogRecPtr lsn,
+										  TimestampTz *timestamp);
+extern TimestampTz GetXLogReplayTimestamp(XLogRecPtr *lsn);
 extern bool RecoveryIsPaused(void);
 extern void SetRecoveryPause(bool recoveryPause);
 extern TimestampTz GetLatestXTime(void);
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index a6cc2eb..80267b4 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2768,7 +2768,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walreceiver.h b/src/include/replication/walreceiver.h
index 28dc1fc..41b248f 100644
--- a/src/include/replication/walreceiver.h
+++ b/src/include/replication/walreceiver.h
@@ -23,6 +23,7 @@
 extern int	wal_receiver_status_interval;
 extern int	wal_receiver_timeout;
 extern bool hot_standby_feedback;
+extern int	replication_lag_sample_interval;
 
 /*
  * MAXCONNINFO: maximum size of a connection string.
@@ -119,6 +120,9 @@ typedef struct
 	 */
 	bool		force_reply;
 
+	/* include the latest replayed timestamp when replying? */
+	bool		force_reply_apply_timestamp;
+
 	/* set true once conninfo is ready to display (obfuscated pwds etc) */
 	bool		ready_to_display;
 
@@ -208,6 +212,6 @@ extern void RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr,
 extern XLogRecPtr GetWalRcvWriteRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI);
 extern int	GetReplicationApplyDelay(void);
 extern int	GetReplicationTransferLatency(void);
-extern void WalRcvForceReply(void);
+extern void WalRcvForceReply(bool sendApplyTimestamp);
 
 #endif   /* _WALRECEIVER_H */
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 7794aa5..fb3a03f 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -46,6 +46,9 @@ typedef struct WalSnd
 	XLogRecPtr	write;
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
+	int64		writeLagUs;
+	int64		flushLagUs;
+	int64		applyLagUs;
 
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
diff --git a/src/include/utils/timestamp.h b/src/include/utils/timestamp.h
index 93b90fe..20517c9 100644
--- a/src/include/utils/timestamp.h
+++ b/src/include/utils/timestamp.h
@@ -233,9 +233,11 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time,
 #ifndef HAVE_INT64_TIMESTAMP
 extern int64 GetCurrentIntegerTimestamp(void);
 extern TimestampTz IntegerTimestampToTimestampTz(int64 timestamp);
+extern int64 TimestampTzToIntegerTimestamp(TimestampTz timestamp);
 #else
 #define GetCurrentIntegerTimestamp()	GetCurrentTimestamp()
 #define IntegerTimestampToTimestampTz(timestamp) (timestamp)
+#define TimestampTzToIntegerTimestamp(timestamp) (timestamp)
 #endif
 
 extern TimestampTz time_t_to_timestamptz(pg_time_t tm);
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index e9cfadb..14147c5 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1809,10 +1809,13 @@ pg_stat_replication| SELECT s.pid,
     w.write_location,
     w.flush_location,
     w.replay_location,
+    w.write_lag,
+    w.flush_lag,
+    w.replay_lag,
     w.sync_priority,
     w.sync_state
    FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn)
-     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) ON ((s.pid = w.pid)))
+     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, write_lag, flush_lag, replay_lag, sync_priority, sync_state) ON ((s.pid = w.pid)))
      LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
 pg_stat_ssl| SELECT s.pid,
     s.ssl,

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 5b67def..816cc9b 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1413,6 +1413,24 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be written on this
+      standby server</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be flushed on this
+      standby server</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Estimated time taken for recent WAL records to be replayed on this
+      standby server</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 2dcff7f..be0aae9 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -11509,6 +11509,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 {
 	static TimestampTz last_fail_time = 0;
 	TimestampTz now;
+	bool		streaming_reply_sent = false;
 
 	/*-------
 	 * Standby mode is implemented by a state machine:
@@ -11832,6 +11833,19 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 					}
 
 					/*
+					 * Since we have replayed everything we have received so
+					 * far and are about to start waiting for more WAL, let's
+					 * tell the upstream server our replay location now so
+					 * that pg_stat_replication doesn't show stale
+					 * information.
+					 */
+					if (!streaming_reply_sent)
+					{
+						WalRcvForceReply();
+						streaming_reply_sent = true;
+					}
+
+					/*
 					 * Wait for more WAL to arrive. Time out after 5 seconds
 					 * to react to a trigger file promptly.
 					 */
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 38be9cf..60047d7 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -705,6 +705,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index ba506e2..62e0110 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -188,6 +188,31 @@ static volatile sig_atomic_t replication_active = false;
 static LogicalDecodingContext *logical_decoding_ctx = NULL;
 static XLogRecPtr logical_startptr = InvalidXLogRecPtr;
 
+/* A sample associating a log position with the time it was written. */
+typedef struct
+{
+	XLogRecPtr lsn;
+	TimestampTz time;
+} WalTimeSample;
+
+/* The size of our buffer of time samples. */
+#define LAG_TRACKER_BUFFER_SIZE 8192
+
+/* Constants for the read heads used in the lag tracking circular buffer. */
+#define LAG_TRACKER_WRITE_HEAD 0
+#define LAG_TRACKER_FLUSH_HEAD 1
+#define LAG_TRACKER_APPLY_HEAD 2
+#define LAG_TRACKER_NUM_READ_HEADS 3
+
+/* A mechanism for tracking replication lag. */
+static struct
+{
+	XLogRecPtr last_lsn;
+	WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE];
+	int write_head;
+	int read_heads[LAG_TRACKER_NUM_READ_HEADS];
+} LagTracker;
+
 /* Signal handlers */
 static void WalSndSigHupHandler(SIGNAL_ARGS);
 static void WalSndXLogSendHandler(SIGNAL_ARGS);
@@ -219,6 +244,8 @@ static long WalSndComputeSleeptime(TimestampTz now);
 static void WalSndPrepareWrite(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static void WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz time);
+static int64 LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
 
 static void XLogRead(char *buf, XLogRecPtr startptr, Size count);
 
@@ -244,6 +271,9 @@ InitWalSender(void)
 	 */
 	MarkPostmasterChildWalSender();
 	SendPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE);
+
+	/* Initialize empty timestamp buffer for lag tracking. */
+	memset(&LagTracker, 0, sizeof(LagTracker));
 }
 
 /*
@@ -1489,6 +1519,10 @@ ProcessStandbyReplyMessage(void)
 				flushPtr,
 				applyPtr;
 	bool		replyRequested;
+	uint64		writeLag,
+				flushLag,
+				applyLag;
+	TimestampTz now;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
@@ -1503,6 +1537,12 @@ ProcessStandbyReplyMessage(void)
 		 (uint32) (applyPtr >> 32), (uint32) applyPtr,
 		 replyRequested ? " (reply requested)" : "");
 
+	/* See if we can compute the round-trip lag for these positions. */
+	now = GetCurrentTimestamp();
+	writeLag = LagTrackerRead(LAG_TRACKER_WRITE_HEAD, writePtr, now);
+	flushLag = LagTrackerRead(LAG_TRACKER_FLUSH_HEAD, flushPtr, now);
+	applyLag = LagTrackerRead(LAG_TRACKER_APPLY_HEAD, applyPtr, now);
+
 	/* Send a reply if the standby requested one. */
 	if (replyRequested)
 		WalSndKeepalive(false);
@@ -1518,6 +1558,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLag != -1)
+			walsnd->writeLag = writeLag;
+		if (flushLag != -1)
+			walsnd->flushLag = flushLag;
+		if (applyLag != -1)
+			walsnd->applyLag = applyLag;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1914,6 +1960,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLag = -1;
+			walsnd->flushLag = -1;
+			walsnd->applyLag = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2239,6 +2288,13 @@ XLogSendPhysical(void)
 	}
 
 	/*
+	 * Record the current system time as an approximation of the time at which
+	 * this WAL position was written for the purposes of lag tracking if it
+	 * has moved forwards.
+	 */
+	LagTrackerWrite(SendRqstPtr, GetCurrentTimestamp());
+
+	/*
 	 * If this is a historic timeline and we've reached the point where we
 	 * forked to the next timeline, stop streaming.
 	 *
@@ -2688,6 +2744,21 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+usecs_to_interval(uint64 usecs)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+#ifdef HAVE_INT64_TIMESTAMP
+	result->time = usecs;
+#else
+	result->time = usecs / 1000000.0;
+#endif
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2696,7 +2767,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2744,6 +2815,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		int64		writeLag;
+		int64		flushLag;
+		int64		applyLag;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2758,6 +2832,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLag = walsnd->writeLag;
+		flushLag = walsnd->flushLag;
+		applyLag = walsnd->applyLag;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2799,7 +2876,22 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			if (writeLag < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(usecs_to_interval(writeLag));
+
+			if (flushLag < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(usecs_to_interval(flushLag));
+
+			if (applyLag < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(usecs_to_interval(applyLag));
+
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2813,12 +2905,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
@@ -2886,3 +2978,85 @@ WalSndKeepaliveIfNecessary(TimestampTz now)
 			WalSndShutdown();
 	}
 }
+
+/*
+ * Record the end of the WAL and the current time, so that we can compute the
+ * lag when this WAL position is eventually reported by the standby.
+ */
+static void
+LagTrackerWrite(XLogRecPtr lsn, TimestampTz time)
+{
+	bool buffer_full;
+	int new_write_head;
+	int i;
+
+	/*
+	 * If the lsn hasn't advanced since last time, then do nothing.  This way
+	 * we only record a new sample when new WAL has been written, which is
+	 * simple proxy for the time at which the log was written.
+	 */
+	if (LagTracker.last_lsn == lsn)
+		return;
+	LagTracker.last_lsn = lsn;
+
+	/*
+	 * If advancing the write head of the circular buffer would crash into any
+	 * of the read heads, then the buffer is full.  In other words, the
+	 * slowest reader (presumably apply) is the one that controls the release
+	 * of space.
+	 */
+	new_write_head = (LagTracker.write_head + 1) % LAG_TRACKER_BUFFER_SIZE;
+	buffer_full = false;
+	for (i = 0; i < LAG_TRACKER_NUM_READ_HEADS; ++i)
+	{
+		if (new_write_head == LagTracker.read_heads[i])
+			buffer_full = true;
+	}
+
+	/*
+	 * If the buffer if full, for now we just rewind by one slot and overwrite
+	 * the last sample, as a simple if somewhat uneven way to lower the
+	 * sampling rate.  There may be better adaptive compaction algorithms.
+	 */
+	if (buffer_full)
+	{
+		new_write_head = LagTracker.write_head;
+		LagTracker.write_head =
+			(LagTracker.write_head - 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	/* Store a sample at the current write head position. */
+	LagTracker.buffer[LagTracker.write_head].lsn = lsn;
+	LagTracker.buffer[LagTracker.write_head].time = time;
+	LagTracker.write_head = new_write_head;
+}
+
+/*
+ * Find out how much time has elapsed since WAL position 'lsn' or earlier was
+ * written to the lag tracking buffer and 'now'.  Return -1 if no time is
+ * available, and otherwise the elapsed time in microseconds.
+ */
+static int64
+LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now)
+{
+	TimestampTz time = 0;
+	int64 result;
+
+	/* Read all unread samples up to this LSN or end of buffer. */
+	while (LagTracker.read_heads[head] != LagTracker.write_head &&
+		   LagTracker.buffer[LagTracker.read_heads[head]].lsn <= lsn)
+	{
+		time = LagTracker.buffer[LagTracker.read_heads[head]].time;
+		LagTracker.read_heads[head] =
+			(LagTracker.read_heads[head] + 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	/* If the clock somehow went backwards, treat as not found. */
+	if (time == 0 || time > now)
+		result = -1;
+	else
+		result = TimestampTzToIntegerTimestamp(now) -
+			TimestampTzToIntegerTimestamp(time);
+
+	return result;
+}
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 9b4c012..664b584 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -1777,6 +1777,20 @@ GetSQLLocalTimestamp(int32 typmod)
 }
 
 /*
+ * TimestampTzToIntegerTimestamp -- convert a native timestamp to int64 format
+ *
+ * When compiled with --enable-integer-datetimes, this is implemented as a
+ * no-op macro.
+ */
+#ifndef HAVE_INT64_TIMESTAMP
+int64
+TimestampTzToIntegerTimestamp(TimestampTz timestamp)
+{
+	return timestamp * 1000000;
+}
+#endif
+
+/*
  * TimestampDifference -- convert the difference between two timestamps
  *		into integer seconds and microseconds
  *
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index 41c12af..246336f 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2772,7 +2772,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 5e6ccfc..3ec7dfb 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -47,6 +47,11 @@ typedef struct WalSnd
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
 
+	/* Lag times in microseconds. */
+	int64		writeLag;
+	int64		flushLag;
+	int64		applyLag;
+
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
 
diff --git a/src/include/utils/timestamp.h b/src/include/utils/timestamp.h
index 21651b1..765fa81 100644
--- a/src/include/utils/timestamp.h
+++ b/src/include/utils/timestamp.h
@@ -108,9 +108,11 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time,
 #ifndef HAVE_INT64_TIMESTAMP
 extern int64 GetCurrentIntegerTimestamp(void);
 extern TimestampTz IntegerTimestampToTimestampTz(int64 timestamp);
+extern int64 TimestampTzToIntegerTimestamp(TimestampTz timestamp);
 #else
 #define GetCurrentIntegerTimestamp()	GetCurrentTimestamp()
 #define IntegerTimestampToTimestampTz(timestamp) (timestamp)
+#define TimestampTzToIntegerTimestamp(timestamp) (timestamp)
 #endif
 
 extern TimestampTz time_t_to_timestamptz(pg_time_t tm);

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index fad5cb0..28984d0 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1417,6 +1417,36 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written it (but not yet
+      flushed it or applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_write</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written and flushed it
+      (but not yet applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_flush</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written, flushed and
+      applied it.  This can be used to gauge the expected delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_apply</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index f23e108..dffadb5 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -11519,6 +11519,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 {
 	static TimestampTz last_fail_time = 0;
 	TimestampTz now;
+	bool		streaming_reply_sent = false;
 
 	/*-------
 	 * Standby mode is implemented by a state machine:
@@ -11842,6 +11843,19 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 					}
 
 					/*
+					 * Since we have replayed everything we have received so
+					 * far and are about to start waiting for more WAL, let's
+					 * tell the upstream server our replay location now so
+					 * that pg_stat_replication doesn't show stale
+					 * information.
+					 */
+					if (!streaming_reply_sent)
+					{
+						WalRcvForceReply();
+						streaming_reply_sent = true;
+					}
+
+					/*
 					 * Wait for more WAL to arrive. Time out after 5 seconds
 					 * to react to a trigger file promptly.
 					 */
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 38be9cf..60047d7 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -705,6 +705,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index ba506e2..c1ebdff 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -188,6 +188,31 @@ static volatile sig_atomic_t replication_active = false;
 static LogicalDecodingContext *logical_decoding_ctx = NULL;
 static XLogRecPtr logical_startptr = InvalidXLogRecPtr;
 
+/* A sample associating a log position with the time it was written. */
+typedef struct
+{
+	XLogRecPtr lsn;
+	TimestampTz time;
+} WalTimeSample;
+
+/* The size of our buffer of time samples. */
+#define LAG_TRACKER_BUFFER_SIZE 8192
+
+/* Constants for the read heads used in the lag tracking circular buffer. */
+#define LAG_TRACKER_WRITE_HEAD 0
+#define LAG_TRACKER_FLUSH_HEAD 1
+#define LAG_TRACKER_APPLY_HEAD 2
+#define LAG_TRACKER_NUM_READ_HEADS 3
+
+/* A mechanism for tracking replication lag. */
+static struct
+{
+	XLogRecPtr last_lsn;
+	WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE];
+	int write_head;
+	int read_heads[LAG_TRACKER_NUM_READ_HEADS];
+} LagTracker;
+
 /* Signal handlers */
 static void WalSndSigHupHandler(SIGNAL_ARGS);
 static void WalSndXLogSendHandler(SIGNAL_ARGS);
@@ -219,6 +244,8 @@ static long WalSndComputeSleeptime(TimestampTz now);
 static void WalSndPrepareWrite(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static void WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+static int64 LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
 
 static void XLogRead(char *buf, XLogRecPtr startptr, Size count);
 
@@ -244,6 +271,9 @@ InitWalSender(void)
 	 */
 	MarkPostmasterChildWalSender();
 	SendPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE);
+
+	/* Initialize empty timestamp buffer for lag tracking. */
+	memset(&LagTracker, 0, sizeof(LagTracker));
 }
 
 /*
@@ -1489,6 +1519,10 @@ ProcessStandbyReplyMessage(void)
 				flushPtr,
 				applyPtr;
 	bool		replyRequested;
+	uint64		writeLag,
+				flushLag,
+				applyLag;
+	TimestampTz now;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
@@ -1503,6 +1537,12 @@ ProcessStandbyReplyMessage(void)
 		 (uint32) (applyPtr >> 32), (uint32) applyPtr,
 		 replyRequested ? " (reply requested)" : "");
 
+	/* See if we can compute the round-trip lag for these positions. */
+	now = GetCurrentTimestamp();
+	writeLag = LagTrackerRead(LAG_TRACKER_WRITE_HEAD, writePtr, now);
+	flushLag = LagTrackerRead(LAG_TRACKER_FLUSH_HEAD, flushPtr, now);
+	applyLag = LagTrackerRead(LAG_TRACKER_APPLY_HEAD, applyPtr, now);
+
 	/* Send a reply if the standby requested one. */
 	if (replyRequested)
 		WalSndKeepalive(false);
@@ -1518,6 +1558,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLag != -1)
+			walsnd->writeLag = writeLag;
+		if (flushLag != -1)
+			walsnd->flushLag = flushLag;
+		if (applyLag != -1)
+			walsnd->applyLag = applyLag;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1914,6 +1960,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLag = -1;
+			walsnd->flushLag = -1;
+			walsnd->applyLag = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2239,6 +2288,32 @@ XLogSendPhysical(void)
 	}
 
 	/*
+	 * Record the current system time as an approximation of the time at which
+	 * this WAL position was written for the purposes of lag tracking.
+	 *
+	 * In theory we could make XLogFlush() record a time in shmem whenever WAL
+	 * is flushed and we could get that time as well as the LSN when we call
+	 * GetFlushRecPtr() above (and likewise for the cascading standby
+	 * equivalent), but rather than putting any new code into the hot WAL path
+	 * it seems good enough to capture the time here.  We should reach this
+	 * after XLogFlush() runs WalSndWakeupProcessRequests(), and although that
+	 * may take some time, we read the WAL flush pointer and take the time
+	 * very close to together here so that we'll get a later position if it
+	 * is still moving.
+	 *
+	 * Because LagTrackerWriter ignores samples when the LSN hasn't advanced,
+	 * this gives us a cheap approximation for the WAL flush time for this
+	 * LSN.
+	 *
+	 * Note that the LSN is not necessarily the LSN for the data contained in
+	 * the present message; it's the end of the the WAL, which might be
+	 * further ahead.  All the lag tracking machinery cares about is finding
+	 * out when that arbitrary LSN is eventually reported as written, flushed
+	 * and applied, so that it can measure the elapsed time.
+	 */
+	LagTrackerWrite(SendRqstPtr, GetCurrentTimestamp());
+
+	/*
 	 * If this is a historic timeline and we've reached the point where we
 	 * forked to the next timeline, stop streaming.
 	 *
@@ -2688,6 +2763,21 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+usecs_to_interval(uint64 usecs)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+#ifdef HAVE_INT64_TIMESTAMP
+	result->time = usecs;
+#else
+	result->time = usecs / 1000000.0;
+#endif
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2696,7 +2786,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2744,6 +2834,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		int64		writeLag;
+		int64		flushLag;
+		int64		applyLag;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2758,6 +2851,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLag = walsnd->writeLag;
+		flushLag = walsnd->flushLag;
+		applyLag = walsnd->applyLag;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2799,7 +2895,22 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			if (writeLag < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(usecs_to_interval(writeLag));
+
+			if (flushLag < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(usecs_to_interval(flushLag));
+
+			if (applyLag < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(usecs_to_interval(applyLag));
+
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2813,12 +2924,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
@@ -2886,3 +2997,94 @@ WalSndKeepaliveIfNecessary(TimestampTz now)
 			WalSndShutdown();
 	}
 }
+
+/*
+ * Record the end of the WAL and the time it was flushed locally, so that
+ * LagTrackerRead can compute the elapsed time (lag) when this WAL position is
+ * eventually reported to have been written, flushed and applied by the
+ * standby in a reply message.
+ */
+static void
+LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time)
+{
+	bool buffer_full;
+	int new_write_head;
+	int i;
+
+	/*
+	 * If the lsn hasn't advanced since last time, then do nothing.  This way
+	 * we only record a new sample when new WAL has been written.
+	 */
+	if (LagTracker.last_lsn == lsn)
+		return;
+	LagTracker.last_lsn = lsn;
+
+	/*
+	 * If advancing the write head of the circular buffer would crash into any
+	 * of the read heads, then the buffer is full.  In other words, the
+	 * slowest reader (presumably apply) is the one that controls the release
+	 * of space.
+	 */
+	new_write_head = (LagTracker.write_head + 1) % LAG_TRACKER_BUFFER_SIZE;
+	buffer_full = false;
+	for (i = 0; i < LAG_TRACKER_NUM_READ_HEADS; ++i)
+	{
+		if (new_write_head == LagTracker.read_heads[i])
+			buffer_full = true;
+	}
+
+	/*
+	 * If the buffer is full, for now we just rewind by one slot and overwrite
+	 * the last sample, as a simple (if somewhat uneven) way to lower the
+	 * sampling rate.  There may be better adaptive compaction algorithms.
+	 */
+	if (buffer_full)
+	{
+		new_write_head = LagTracker.write_head;
+		LagTracker.write_head =
+			(LagTracker.write_head - 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	/* Store a sample at the current write head position. */
+	LagTracker.buffer[LagTracker.write_head].lsn = lsn;
+	LagTracker.buffer[LagTracker.write_head].time = local_flush_time;
+	LagTracker.write_head = new_write_head;
+}
+
+/*
+ * Find out how much time has elapsed between the moment WAL position 'lsn'
+ * (or the highest known earlier LSN) was flushed locally and the time 'now'.
+ * We have a separate read head for each of the reported LSN locations we
+ * receive in replies from standby; 'head' controls which read head is
+ * used.  Whenever a read head crosses an LSN which was written into the
+ * lag buffer with LagTrackerWrite, we can use the associated timestamp to
+ * find out the time this LSN (or an earlier one) was flushed locally, and
+ * therefore compute the lag.
+ *
+ * Return -1 if no new sample data is available, and otherwise the elapsed
+ * time in microseconds.
+ */
+static int64
+LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now)
+{
+	TimestampTz time = 0;
+	int64 result;
+
+	/* Read all unread samples up to this LSN or end of buffer. */
+	while (LagTracker.read_heads[head] != LagTracker.write_head &&
+		   LagTracker.buffer[LagTracker.read_heads[head]].lsn <= lsn)
+	{
+		time = LagTracker.buffer[LagTracker.read_heads[head]].time;
+		LagTracker.read_heads[head] =
+			(LagTracker.read_heads[head] + 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	/* If the clock somehow went backwards, treat as not found. */
+	if (time == 0 || time > now)
+		result = -1;
+	else
+		result = TimestampTzToIntegerTimestamp(now) -
+			TimestampTzToIntegerTimestamp(time);
+
+	return result;
+}
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 9b4c012..664b584 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -1777,6 +1777,20 @@ GetSQLLocalTimestamp(int32 typmod)
 }
 
 /*
+ * TimestampTzToIntegerTimestamp -- convert a native timestamp to int64 format
+ *
+ * When compiled with --enable-integer-datetimes, this is implemented as a
+ * no-op macro.
+ */
+#ifndef HAVE_INT64_TIMESTAMP
+int64
+TimestampTzToIntegerTimestamp(TimestampTz timestamp)
+{
+	return timestamp * 1000000;
+}
+#endif
+
+/*
  * TimestampDifference -- convert the difference between two timestamps
  *		into integer seconds and microseconds
  *
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index bb7053a..c1e9d4e 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2772,7 +2772,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 5e6ccfc..3ec7dfb 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -47,6 +47,11 @@ typedef struct WalSnd
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
 
+	/* Lag times in microseconds. */
+	int64		writeLag;
+	int64		flushLag;
+	int64		applyLag;
+
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
 
diff --git a/src/include/utils/timestamp.h b/src/include/utils/timestamp.h
index 21651b1..765fa81 100644
--- a/src/include/utils/timestamp.h
+++ b/src/include/utils/timestamp.h
@@ -108,9 +108,11 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time,
 #ifndef HAVE_INT64_TIMESTAMP
 extern int64 GetCurrentIntegerTimestamp(void);
 extern TimestampTz IntegerTimestampToTimestampTz(int64 timestamp);
+extern int64 TimestampTzToIntegerTimestamp(TimestampTz timestamp);
 #else
 #define GetCurrentIntegerTimestamp()	GetCurrentTimestamp()
 #define IntegerTimestampToTimestampTz(timestamp) (timestamp)
+#define TimestampTzToIntegerTimestamp(timestamp) (timestamp)
 #endif
 
 extern TimestampTz time_t_to_timestamptz(pg_time_t tm);

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index fad5cb0..28984d0 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1417,6 +1417,36 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written it (but not yet
+      flushed it or applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_write</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written and flushed it
+      (but not yet applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_flush</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written, flushed and
+      applied it.  This can be used to gauge the expected delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_apply</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index f23e108..dffadb5 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -11519,6 +11519,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 {
 	static TimestampTz last_fail_time = 0;
 	TimestampTz now;
+	bool		streaming_reply_sent = false;
 
 	/*-------
 	 * Standby mode is implemented by a state machine:
@@ -11842,6 +11843,19 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 					}
 
 					/*
+					 * Since we have replayed everything we have received so
+					 * far and are about to start waiting for more WAL, let's
+					 * tell the upstream server our replay location now so
+					 * that pg_stat_replication doesn't show stale
+					 * information.
+					 */
+					if (!streaming_reply_sent)
+					{
+						WalRcvForceReply();
+						streaming_reply_sent = true;
+					}
+
+					/*
 					 * Wait for more WAL to arrive. Time out after 5 seconds
 					 * to react to a trigger file promptly.
 					 */
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 38be9cf..60047d7 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -705,6 +705,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index ba506e2..c6334df 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -188,6 +188,26 @@ static volatile sig_atomic_t replication_active = false;
 static LogicalDecodingContext *logical_decoding_ctx = NULL;
 static XLogRecPtr logical_startptr = InvalidXLogRecPtr;
 
+/* A sample associating a log position with the time it was written. */
+typedef struct
+{
+	XLogRecPtr lsn;
+	TimestampTz time;
+} WalTimeSample;
+
+/* The size of our buffer of time samples. */
+#define LAG_TRACKER_BUFFER_SIZE 8192
+
+/* A mechanism for tracking replication lag. */
+static struct
+{
+	XLogRecPtr last_lsn;
+	WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE];
+	int write_head;
+	int read_heads[NUM_SYNC_REP_WAIT_MODE];
+	WalTimeSample last_read[NUM_SYNC_REP_WAIT_MODE];
+} LagTracker;
+
 /* Signal handlers */
 static void WalSndSigHupHandler(SIGNAL_ARGS);
 static void WalSndXLogSendHandler(SIGNAL_ARGS);
@@ -219,6 +239,8 @@ static long WalSndComputeSleeptime(TimestampTz now);
 static void WalSndPrepareWrite(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static void WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+static int64 LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
 
 static void XLogRead(char *buf, XLogRecPtr startptr, Size count);
 
@@ -244,6 +266,9 @@ InitWalSender(void)
 	 */
 	MarkPostmasterChildWalSender();
 	SendPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE);
+
+	/* Initialize empty timestamp buffer for lag tracking. */
+	memset(&LagTracker, 0, sizeof(LagTracker));
 }
 
 /*
@@ -1489,6 +1514,10 @@ ProcessStandbyReplyMessage(void)
 				flushPtr,
 				applyPtr;
 	bool		replyRequested;
+	uint64		writeLag,
+				flushLag,
+				applyLag;
+	TimestampTz now;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
@@ -1503,6 +1532,12 @@ ProcessStandbyReplyMessage(void)
 		 (uint32) (applyPtr >> 32), (uint32) applyPtr,
 		 replyRequested ? " (reply requested)" : "");
 
+	/* See if we can compute the round-trip lag for these positions. */
+	now = GetCurrentTimestamp();
+	writeLag = LagTrackerRead(SYNC_REP_WAIT_WRITE, writePtr, now);
+	flushLag = LagTrackerRead(SYNC_REP_WAIT_FLUSH, flushPtr, now);
+	applyLag = LagTrackerRead(SYNC_REP_WAIT_APPLY, applyPtr, now);
+
 	/* Send a reply if the standby requested one. */
 	if (replyRequested)
 		WalSndKeepalive(false);
@@ -1518,6 +1553,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLag != -1)
+			walsnd->writeLag = writeLag;
+		if (flushLag != -1)
+			walsnd->flushLag = flushLag;
+		if (applyLag != -1)
+			walsnd->applyLag = applyLag;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1914,6 +1955,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLag = -1;
+			walsnd->flushLag = -1;
+			walsnd->applyLag = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2239,6 +2283,32 @@ XLogSendPhysical(void)
 	}
 
 	/*
+	 * Record the current system time as an approximation of the time at which
+	 * this WAL position was written for the purposes of lag tracking.
+	 *
+	 * In theory we could make XLogFlush() record a time in shmem whenever WAL
+	 * is flushed and we could get that time as well as the LSN when we call
+	 * GetFlushRecPtr() above (and likewise for the cascading standby
+	 * equivalent), but rather than putting any new code into the hot WAL path
+	 * it seems good enough to capture the time here.  We should reach this
+	 * after XLogFlush() runs WalSndWakeupProcessRequests(), and although that
+	 * may take some time, we read the WAL flush pointer and take the time
+	 * very close to together here so that we'll get a later position if it
+	 * is still moving.
+	 *
+	 * Because LagTrackerWriter ignores samples when the LSN hasn't advanced,
+	 * this gives us a cheap approximation for the WAL flush time for this
+	 * LSN.
+	 *
+	 * Note that the LSN is not necessarily the LSN for the data contained in
+	 * the present message; it's the end of the the WAL, which might be
+	 * further ahead.  All the lag tracking machinery cares about is finding
+	 * out when that arbitrary LSN is eventually reported as written, flushed
+	 * and applied, so that it can measure the elapsed time.
+	 */
+	LagTrackerWrite(SendRqstPtr, GetCurrentTimestamp());
+
+	/*
 	 * If this is a historic timeline and we've reached the point where we
 	 * forked to the next timeline, stop streaming.
 	 *
@@ -2688,6 +2758,21 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+usecs_to_interval(uint64 usecs)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+#ifdef HAVE_INT64_TIMESTAMP
+	result->time = usecs;
+#else
+	result->time = usecs / 1000000.0;
+#endif
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2696,7 +2781,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2744,6 +2829,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		int64		writeLag;
+		int64		flushLag;
+		int64		applyLag;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2758,6 +2846,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLag = walsnd->writeLag;
+		flushLag = walsnd->flushLag;
+		applyLag = walsnd->applyLag;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2799,7 +2890,22 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			if (writeLag < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(usecs_to_interval(writeLag));
+
+			if (flushLag < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(usecs_to_interval(flushLag));
+
+			if (applyLag < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(usecs_to_interval(applyLag));
+
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2813,12 +2919,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
@@ -2886,3 +2992,138 @@ WalSndKeepaliveIfNecessary(TimestampTz now)
 			WalSndShutdown();
 	}
 }
+
+/*
+ * Record the end of the WAL and the time it was flushed locally, so that
+ * LagTrackerRead can compute the elapsed time (lag) when this WAL position is
+ * eventually reported to have been written, flushed and applied by the
+ * standby in a reply message.
+ */
+static void
+LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time)
+{
+	bool buffer_full;
+	int new_write_head;
+	int i;
+
+	/*
+	 * If the lsn hasn't advanced since last time, then do nothing.  This way
+	 * we only record a new sample when new WAL has been written.
+	 */
+	if (LagTracker.last_lsn == lsn)
+		return;
+	LagTracker.last_lsn = lsn;
+
+	/*
+	 * If advancing the write head of the circular buffer would crash into any
+	 * of the read heads, then the buffer is full.  In other words, the
+	 * slowest reader (presumably apply) is the one that controls the release
+	 * of space.
+	 */
+	new_write_head = (LagTracker.write_head + 1) % LAG_TRACKER_BUFFER_SIZE;
+	buffer_full = false;
+	for (i = 0; i < NUM_SYNC_REP_WAIT_MODE; ++i)
+	{
+		if (new_write_head == LagTracker.read_heads[i])
+			buffer_full = true;
+	}
+
+	/*
+	 * If the buffer is full, for now we just rewind by one slot and overwrite
+	 * the last sample, as a simple (if somewhat uneven) way to lower the
+	 * sampling rate.  There may be better adaptive compaction algorithms.
+	 */
+	if (buffer_full)
+	{
+		new_write_head = LagTracker.write_head;
+		LagTracker.write_head =
+			(LagTracker.write_head - 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	/* Store a sample at the current write head position. */
+	LagTracker.buffer[LagTracker.write_head].lsn = lsn;
+	LagTracker.buffer[LagTracker.write_head].time = local_flush_time;
+	LagTracker.write_head = new_write_head;
+}
+
+/*
+ * Find out how much time has elapsed between the moment WAL position 'lsn'
+ * (or the highest known earlier LSN) was flushed locally and the time 'now'.
+ * We have a separate read head for each of the reported LSN locations we
+ * receive in replies from standby; 'head' controls which read head is
+ * used.  Whenever a read head crosses an LSN which was written into the
+ * lag buffer with LagTrackerWrite, we can use the associated timestamp to
+ * find out the time this LSN (or an earlier one) was flushed locally, and
+ * therefore compute the lag.
+ *
+ * Return -1 if no new sample data is available, and otherwise the elapsed
+ * time in microseconds.
+ */
+static int64
+LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now)
+{
+	TimestampTz time = 0;
+
+	/* Read all unread samples up to this LSN or end of buffer. */
+	while (LagTracker.read_heads[head] != LagTracker.write_head &&
+		   LagTracker.buffer[LagTracker.read_heads[head]].lsn <= lsn)
+	{
+		time = LagTracker.buffer[LagTracker.read_heads[head]].time;
+		LagTracker.last_read[head] =
+			LagTracker.buffer[LagTracker.read_heads[head]];
+		LagTracker.read_heads[head] =
+			(LagTracker.read_heads[head] + 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	if (time > now)
+	{
+		/* If the clock somehow went backwards, treat as not found. */
+		return -1;
+	}
+	else if (time == 0)
+	{
+		/*
+		 * We didn't cross a time.  If there is a future sample that we
+		 * haven't reached yet, and we've already reached at least one sample,
+		 * let's interpolate the local flushed time.  This is mainly useful for
+		 * reporting a completely stuck apply position as having increasing
+		 * lag, since otherwise we'd have to wait for it to eventually start
+		 * moving again and cross one of our samples before we can show the
+		 * lag increasing.
+		 */
+		if (LagTracker.read_heads[head] != LagTracker.write_head &&
+			LagTracker.last_read[head].time != 0)
+		{
+			double fraction;
+			WalTimeSample prev = LagTracker.last_read[head];
+			WalTimeSample next = LagTracker.buffer[LagTracker.read_heads[head]];
+
+			Assert(lsn >= prev.lsn);
+			Assert(prev.lsn < next.lsn);
+
+			if (prev.time > next.time)
+			{
+				/* If the clock somehow went backwards, treat as not found. */
+				return -1;
+			}
+
+			/* See how far we are between the previous and next samples. */
+			fraction =
+				(double) (lsn - prev.lsn) / (double) (next.lsn - prev.lsn);
+
+			/* Scale the local flush time proportionally. */
+			time = (TimestampTz)
+				((double) prev.time + (next.time - prev.time) * fraction);
+		}
+		else
+		{
+			/* Couldn't interpolate due to lack of data. */
+			return -1;
+		}
+	}
+
+	/* Return the elapsed time since local flush time in microseconds. */
+	Assert(time != 0);
+	return TimestampTzToIntegerTimestamp(now) -
+		TimestampTzToIntegerTimestamp(time);
+}
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 9b4c012..664b584 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -1777,6 +1777,20 @@ GetSQLLocalTimestamp(int32 typmod)
 }
 
 /*
+ * TimestampTzToIntegerTimestamp -- convert a native timestamp to int64 format
+ *
+ * When compiled with --enable-integer-datetimes, this is implemented as a
+ * no-op macro.
+ */
+#ifndef HAVE_INT64_TIMESTAMP
+int64
+TimestampTzToIntegerTimestamp(TimestampTz timestamp)
+{
+	return timestamp * 1000000;
+}
+#endif
+
+/*
  * TimestampDifference -- convert the difference between two timestamps
  *		into integer seconds and microseconds
  *
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index bb7053a..c1e9d4e 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2772,7 +2772,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 5e6ccfc..3ec7dfb 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -47,6 +47,11 @@ typedef struct WalSnd
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
 
+	/* Lag times in microseconds. */
+	int64		writeLag;
+	int64		flushLag;
+	int64		applyLag;
+
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
 
diff --git a/src/include/utils/timestamp.h b/src/include/utils/timestamp.h
index 21651b1..765fa81 100644
--- a/src/include/utils/timestamp.h
+++ b/src/include/utils/timestamp.h
@@ -108,9 +108,11 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time,
 #ifndef HAVE_INT64_TIMESTAMP
 extern int64 GetCurrentIntegerTimestamp(void);
 extern TimestampTz IntegerTimestampToTimestampTz(int64 timestamp);
+extern int64 TimestampTzToIntegerTimestamp(TimestampTz timestamp);
 #else
 #define GetCurrentIntegerTimestamp()	GetCurrentTimestamp()
 #define IntegerTimestampToTimestampTz(timestamp) (timestamp)
+#define TimestampTzToIntegerTimestamp(timestamp) (timestamp)
 #endif
 
 extern TimestampTz time_t_to_timestamptz(pg_time_t tm);

�PNG


IHDR�
�,�
;PLTE���������������@��Ai��� �@���0`��@�������**��@��333MMMfff�������������������22�������U����������������d�"�".�W��p��������������P����E��r��z�����k������� �����������P@Uk/���@�@��`��`�����@��@��`��p������������������������|�@�� ������???������___'''�sV��^:7	pHYs��
�+qIDATx���v���:��] x����!�	�$����s�8�b��D��*��h5}�T[G�x ��j��/��4j������7�4��k#`�t�]�'���P+�
!V��'n��&�����4g��k@�,�������
���m)���r.���U{4
��_!@�w9����f�1��� p���K�I��i�@X���g�����dBT�`fu{��Zt�TdBa&q{e_��[en�vJ����6n�������Ukfs+�t��k@s��fwo������u}5t�9V��VD�i�;��\g�I���:7x�br�5���h	n1����U{pb����ZC@�������i�����};�!�0^	�'�V
s
�T��~  �i�j����%�6��yn
aOm:���U��}4���o�! D
!*QA@�
BT����}����f�s�ST���[���������eC��x��C|��X6,��l��i��p����cgnCk��x
������,g�E��{o����M2Bd$�^RPm~����8�BFVm[[�����Q�I�����c?����!`^��7
�'��0��<WYh�O���5��X{��2pph��V�Y���G���p����j:�:��5�]0I�
� `p
c�!�s
D� ��g-��#o
@��Z�+�W��z�\����b�9"�d(�L:�_-��+s�.��'��X�����0���n�����R>�����������-�M��6o�%�;�Y�"�}D��IW@SP��)U���!����r�=�����O����������.����2���M=���1�Z1���YZ1=?�����S�t������9�����D�`]���+`��Z�3`SU���yS�i��*��3���8:I��o�*`�yc��=�
#����R��D���[�������$#D�P�g��1H�lwHc
���W�P������NDw�3�0�
�������X���P`�.�@�
�W��H��� `xp�
7 `xp�
7 `xp�
7 `xp�
7 `xp�
7 `xp�
7 `p�o
� `pp
� `pp
� `pp
� `pp
� `pp
� `pp���@�� �|
C��o `h�

����p��
dVL7K�5�-�^]Cd����U�_��l
��"+��v9�aW��h
��*B+�W�E�����w��
�5M
��#�V�~�5 ^GJ��A���
������bWLG��H��~t����x�_���D�����x	
5���"�
$#��n��wA�[ �]�x���
���7A�{ �=��&x�	^���A�K,����]��Y=�^�5���A�+�6_p��z�C�� �
��>x�u���q�B�C7�:@K���q��7����_k����������n�fJ���������2
}��E��y��#G�ZJ��
��� �W�i����F^ZJ��������<.D@�����PU���.���6�g-���������
�Z(Sz��.��6��.����P��.�<�>Qj���}�S���
=sB��H��0�&�O��q��A���A@��i1C���ZuP��gK����q�b���- �y�}pN�z�< z��N�4��������.���.�m��o.'D# ���`�_�,@@���}��HD@8Bf���U���I����Z������j�z�L����
�?��WL��J]�nK���
��!,+��v�����O�3	��XVL���m
[�
EpOHm\�B@8���j����B�?����?�z� ��=L�����EBP�3Zh�u$</Xm����a�O�����%�.u"
�p��Q��u������[q(�{>`c�5�D@!NOD?3#�� #�	��}"���(�.���2���fD#�'�
�+g@���k@������'��Qp��Q0��<�(����?AN����D@A��
rfP7����(�-���O���'��M�T�-!�KK�����HHU}KH��Rj �$�R��a�O�S���lK�����=>/%
E9Q������'���27���P��o�O�sZ�" ����i�>����,�?i����n?<k�B��}���x�{�R](���h�X���?q���Z������`�}���W�JF�?yNh����R

�q����'�-%�������t_��n��' ��Q���,�0�>��RB `�!�{�8�~��@8-��B�����!����*�-��z�7��p��v���lMn�_D�(b�t�{:�L7|��1]p�{��Ap�bP�`����!)z8XU.3
�/�N=j=8ddu�9�D@8�LF������ms����F@yN)�S��kV~cWj���Z3����`�w�f���dE����y������E
q�D����a<]�}����P\X������UEd8����9	��8Q��3��x,
�qb2�a����0g�aL���
�/g*#��X!����{�
����Sk���pD������s��|K�A��P!��	O�}��!q�
�A��@���i�6���
]�
�A�� ���@�� ����q��� �Rl00�5���[*#������-��B���:WF(�N��Be��"��9W�o>���RD08*#�������|���������R���"���q��i���?���p���U�%?��p��i��%O� `�TFX�d[������)���1p���j����F���X�D4�E�������z�����Q85
�JN�B�(8���:5%������/nZ�����t����i@�88k����X����C@8�lJ�v��}-U�������(�����wB���Z�w
���p����6�m���bKQ@�HHh1-�^gu
���8���n����l�V��b:����S2�K2L,�����DJ~�{����f7
���8��Z9&��
H^����d�4�����R�/��1 `4N-VXlm��a�S)�u�)���s�an���p����v��?��-
�q��`�8}��� `<D&�����E�0*�Zt�`S�B5���]�4����m)������W����U�^�[��C+���
"`LZ������1yf����
���E�� ��)�~�	B��"��!`T�V���aE��/5�U����YE�09��a�dC�jI�K���Z�D�@�������(Py�%)0E$
T�lI�K���c!`�<F@�K��<E@�K��<D@�K��  D
!*���
!*bZ���i����?���B>=Q@�K!-�:�.
�EF��M�
�ED�^+�"ZtCZ�`L	-jS��S�h+��_�H)��O���b:&�&�0a��
�/e����)�������)^@�K�����)\@�K�����)Z@�K����@@�J��_�+ �eA��_* ���B��_6) ��C��_F�"���-$O!�6�!`N�!�k��eE1.��_^!�k}���(A��s���Q����;��G�2�������A@�J��_�d. ��N��_�d- ��BTr�
 c
����� [
��r�
!S
���V�Tm#����b�������� !�Y����V�%,�k�z�_K�WrvRg@�+	1
��5 ������b��WB�m���������VL?:��R�
CD�#�����!"�g���%�+	
5��n	��#�d�+����A@�J>�_�d# ��I.�_�d" ��J�_�d! ��K�_�d  ��L��_�$/ ��M��_��- +O���HX@�{�
����* �=�D�����������C����HP@�{�	��"9
��Y�& �=����������8���GB�~�D��I2��3IE@�{(��O%

���$! �=���##`��N���OFD�F5}�[&���������dV��v�u���i��}���&�
��t���������l��������x���&�A���qY��upl������C/����
�>�og���v�fW�?�����i�:��v�5���Z�t������g����q�����7oz���&??�=�fu8��,���������v;�u��q�����>#|%���_�E�]Kx<
E[W��0�8�����8(����Um#�����;eoy����X+��s`�C�������&�H�Z
����j�]n��Y��[5E��z�>�<��&��cJyZ��ZY
���$v�[v�k�FM��A}E�K�w��cj%�������S�J �r����<������9���RT}����	sD��j���t���k����'kP_���"�p�X�E�����������n$v��Rf�����=R
�"�,W;�p-�?~���3P��9N��M�v�������W`�I�I_����T��[
}F_�9��\d��d������B/4i�G���`�AH�
(t?�H��w^&���=p�N���<@�=����_�)��!|Cb�������LD�
����0^js=��&��%�;�o�4KO����F�����%p����g�B����92���}����D�}#�q>�+v�����'q6���������V�k
 �
b�3��>,�����)�������Aj������Uc6��y�u�jy"�3�������a���������d3cwg�=S��m����7�Y.[����Am��F��7����7��s�G�z~�m�+�z�����#?��Dz{������&e�a���~�����{
m����������~	S���d�\�oi@�h���ZM���7Cg��?���mk��j*Q0����fp��n2]Z�����K�=m7�]�?R�(_�,�����V]����&/�^p�x5o5�7��p��n2	�fp��&������m���Vl����j:����Wz��r:n�M���[�3����3`��Wa�
��7x��l��3n�n�~
8	�s]gh�MK�0o����o
�?p
X2���$QoG������\p�m��� �^F�f��!���k�a[��g<�4�~�Qp��3r�S��65t�0��5�R�^=o>������|�g�j��wf7X�g����#�>�3�E�p�FwB�G
/���y��^����5~v"�`�Z���L�IEND�B`�

�PNG


IHDR�
�,�
;PLTE���������������@��Ai��� �@���0`��@�������**��@��333MMMfff�������������������22�������U����������������d�"�".�W��p��������������P����E��r��z�����k������� �����������P@Uk/���@�@��`��`�����@��@��`��p������������������������|�@�� ������???������___'''�sV��^:7	pHYs��
�+>IDATx���
��*�Ee���
�[���I�vE��b��Z�;��8te_D�*��������xh/�|	���5~xcW�7n�
@^������7�_���xa����&����7�����)mm�hq}^�mk�� /K
�^H�����"BnVg��7�ae��@n&
��4{��{=����p�2���P�N��
�M���1�6v�x���c1w�7���U5C�/�m�ux����)5W��)u�-�;�M]����E�tJ�UU3�z�t(�KA@xC�}���B@@�A��V>��"�8�&���mL���c�<�!
��p��&�N5�y�
���zc(��  ���s�S8����"�of���I������v�I7X������N�w�t���*�[�{�^XLh�_
i��5�m�S<�f�������w��`��4��k��
=q����r��Zlk6}��q���["x�0Ncj�g3����0(�%����,
O
�~X��@�K��a�w
?,�n ����
����q���5��xs��}�>�$�m��l���$`X�
a�96��i��p���o��J���y�3xN>N��0����_�5�k��������>\tl��kA��p����R�%���F��+�Hw]��T��s��q�i34�a>>~;'�5�[�wB�a�
�vN����l[���+�"���d�K��a�w
?,�n ����
�������~7��������j
�~X��@�K�gV����JXO/�=x[��|�'�
t�p�X?<2������u�s*0m���o�H�<N0��	������[����,�/��Uv��0�pF���5�p���9X���>o'~..�����!���Z_
S8A@kZ�������>^�qZ���Ia#1�>V�>�[��0����[;��^�	�������
����qZ�Y��H~
�O��H��~��/��)��X�
S�/����&>�^��O/l����3'�
+�Z�

S8�����E�wE��������g�� ���V����S�d���'������j��C�~����nO��/��f��+�0��o��W�T!`���f���������#`���9�V\�ps�w,>47LF8�@�C �
<�@�C\���G���@@xT���@@xT���@@xT���@@xT���@@xT���@@xT���@@xT���@@xT���@@xT���@@xT���@@xT���@@xT���@@xT������"w&~X�@@xT���@@xT���@@xT���@@x�K\@�OK?�@�# �<�@�# �<�@�# ��
L�dF�M2}����~
(C��b�`7l�6��F��C��W�	{��6J����gJ?�!W`p�>�f��n���I?	�!W`hk����ml��46{�I ��t�������@,=4;��M7�������lN�}�>}���f�58
����_tB���+�Xu�I ���0�Bo���s�xL��s@@����w���~(#��������w�=������2��p���G@@�p�k;���%�,P�N|�V��m�q?-zq ��}
����~���u_"szy ��}
��-�����1�<P��# ��4\�5����r@@�paZ�1��'����@���t~{fs���@@�h|�Q��� `�������X!`��B�7����U5Mp��B�wB��[�j5�����@@	
���+��
e0}���V������
�#�]����l��������@@���,V(d�8�8�q�

���2���*W��
e�o���W��N�F��C5��_�.>`)�D��C5�����k�t@,>tQ=D

e�W�2=��2�wBL�E.I/��P;
!1�0PF����
e���Z_�^(c��t6rIza ���M��%����2<�HQ�9uO
K]�@O�@tl����X|��zv+P���<@@������]/���H��\!�fD

e��fF�����# ������?y>�w��-���r\!�Ou���*�I��q
�V
3����=��

���������-
Ed|�8���F@I��>i0n�>n��?m�t�opp�>;g�i����V��.a����6O?�r�S��f�LQ�'�G]���[�w��iM�0!u%�oV�7&e~����jS%LH����f����)��@@	I�3)�0�N����3`b��	H����G��a��C����p<&L���hS�
e$��`����	������z|�}1���I�_-��X&��(�%z���2�pb0)���/�JN�:&e~��a<��|��
�?�+�����+��2R��]
�P��&��p3��	�P��N�1}+\�:V
e$(��?�H/
��O
������q�_-`��i���y-9��
u�T���
�4t�����^�c'�w���X�� ��i8�@� �<�@� �<�@� �����F��q@��[��4]��Z��h,<tQ�Kn��N9#
]������F�N,<tQ�K�����G��C5��	[uUaV��	�P��%z������E
����>�����.jP�@�ti,<tQ�K�m���LT��	�L���^q�$e&L��
�����c��

���	����D@%I{�����{;'�,PG�@t���I/
��
�@@��>���6�����
���0O��^��&��
��:��
��:��#���"�.F���^>M����.kp�����}�&8<�#�r�����@@;����vZ���q	�i��^�A�������e
.l�+#���+w��7g���{�!`���\(����}*}hk��p_
�m�Y������.kp����~�U��4����4
]���&8�����Yl�?_.z"Xx��W��+#��$���'
�re7���s���89��L��}]�����	�^�?���R��V���t�8SF
�s���L�j
��?]�x.}1=���NL�z�
�B�Y��t�����P�t+n�p�w�iV?��i��,`������^�#ee�������;�S��3��=���e��:���`�3;�����HXp�@t���@@���\�%��:v+0�����$�\����'�,P���9���z��d�~��X%
��V��������@@�S�/J/��:%����@@	wB:�A@��`��A@�
s����s��@L�j
���K@L�f
kc�w{���H/��4!�bBj
u�NF`J~��J�k��I/���Y���a������
�)�(�����k�Z���g��A@ik��g� `Z�Wh��^��qRzQ ��������@�
P�|��<�e��:v+�����j����H�lm]wq^���e��:�gD+'E#`Z�7�L��r
�-R�+� �W@}����I/
��a���e��:X����E�������E�gP�����BX�<�"�� ����0�8��B.^����
Y@@!9����q���� `q��\�N]�r�q�k�n��\�'��jB�y�:�6x��u
��'�M��z�v�Z�[��7������%��.t]��
XUx��u
�PH~
�/l	���A��B�5�V@�������3�
C�5����g����]��wp1���]��N���F�v���J��t,.t],��� ������(
�A@!�
A�tP��������3
��"`�t|��9��m����L@�tP���B0��� �L
� `:(
�A@!�
A�tP���B0��� �L
� `:(
�A@!�
A�tP���B0���|��� `:(
�A@!%	xP���B0��� �L
� `:(
�A@!�
A�tP���B0��� ��N�d���qw���t|���y�&x~��6�g:�E��4a��i���M��HG�w��o����M�l}���](�ehk���}�i��4�M:�E���C@���������o������ `b(�ern�&�u�����[|�Y.>~
���Dj���,
�a���<3��}�r,
C�=��m������](�`����o�u�i�7��.
��#��P�����B0k:�E����.
��#��P�����2/�!`1 ������(
�A@!�
A�d.q

���E�n�
/
� `2�
�A@%�*A�dP	&��J0����C0k:���7���*A�dP	&��J0T��� �L��T�
�A@%�*A�dP	&��J0T��� �L
� `2�
�A@%�*A�dPIY��@T��� �L
� `2�
�A@%�*A�dP	&��J�p�7��t|��Gy�F����&
���=��������oB� ��=��7��]��Y9�����&	���3�zS
]l}�E|'
��!���'��3�
_���E�R��?�Y�o����0��^T//B�����$����
���f�������/l��y�������_���u������N��{���_5���$�v'�,[��a�bs �4�n�
��#��i�%����R]k��!i�sY�B��Q�Xj�Ol�{#m�B����	JKu}=����q}]��P�����DM�c��>�]lN���|�����LPZj,G]�v�������%J�K����"��k�%76�~���U�R��QW�3�>T�K�=�:���Y��)��m�%�����JKuf��������P����\�����
�'��<��������\�:\{���v����J��?��d	�rU����l������Vf��v�=I�o��U�/L�I�R�x����*
�����j
��������%������%���>C'���:�A���:!�,`�Ol7�I���&C��`i��<�+u�����*s����R�}b{�>��y�����"���k@>Ke�6�@��u�Ol��/��X��V\��&T�����g�����f��J&>���n������
^�0��K8"`��~\�y&�I@���W�K���	�Y�c�}��)7�Ac�e��R�{2�(^|����p�����V����b��<�/���)`���}�>;>����.>f��q���?���
����<�
���w����O��s��;>�����"�P�!`����G���x��?�hA]
�D����(i��e�����c#����b����,Y\*�/o
p���f^M#����
��7��l����)����p=8.-�������n8�/w�b+��fz�56����3`]
^������x�����]���x� ���A�q%�
���G�}]�+��Mq���>�Q��-�=��v�
��M���K1;����T�
?��*�7`���^�"�V����z���|\���)iQ��5�(�K���k�O&��2H�c��4C���]����I�S/8��W>�
D�7��k�<z���S��#��?�qD.Vv�a5��czuk�<�g����V\34��>���5���Y�V�u��q�/$����|#�;!_�P�C���?wD(���0O���p	�R�����Z$IEND�B`�

�PNG


IHDR�
�,�
;PLTE���������������@��Ai��� �@���0`��@�������**��@��333MMMfff�������������������22�������U����������������d�"�".�W��p��������������P����E��r��z�����k������� �����������P@Uk/���@�@��`��`�����@��@��`��p������������������������|�@�� ������???������___'''�sV��^:7	pHYs��
�+�IDATx�����8E�:��Y��3��
�@R���@�w����4%��;�����*�J��������
��U(/�2A��p�v/ll��xe-�B�+�>~���j�s������3��r��NC@p!��������
�	�lw|�'!��H�FaW#���w��.��|]�Z5
�6e,g}���B���Q���(c�h�5����8�U��K��
�n�
��=��-:W�3
r���
�
  8�4�.���+mU����R���EJ  �K������R��!�c��������@@�_�u!M�L;��0��ot�
��v'���M�q���4�N+�'F����thU�+`at���-Ld��`���6��'|�
�2���)pl��l�A���
M��D��A@0�&��g�[@���X�zI}K�1y&�K�5l�c�H~K�K���R  ��p^W�|6/x~&�^�	��|A&0�G������L~
�D�zq&���s�m��
�����6���l�*����Z}������%o{
�.
�=`/`�wH�[/1
l���u#
}?5������A��B#`c��
���B�E>Hx/��	,����z��=��J�o����y?��foC��!�<��c�9|�������*!���F��0O>��s,�����V��G��\mZ�'!�����-���"I��!|����k�l��Q��8����05'����e���\H{D��,83n

��5�R �Z�u���3�,�B��B@b%\��aX�{��x�x-���C83����`g&����o��s+.N�����Q��2U�k����LG���^��v^�����0u���
���/�x���>��p[L}}+�R:�C����F�'>�#f��s i>S���_�r���#|��m10���+G|�����H�y#�sq�iP+�}�����z�����Q���&2B��11����77>^�	���>�C�	$�[")�
/t�w�s`�4�d[/`��+�B7�Y~�B�>�c6&5��*��T$�������|�,&]�q+d��1�
��L��Y@��� ���V�L@���!�� �< ���a<9S�@@����T+�D��'g�($S������R ��Lu�[3xr�:��b2U��e��LU2g�d!�3�u�&
K�JcsWa�L�X(��e��C/�d^�z��	)MG��@@F `����+ROc��j��	)+u�G�y@�L�N<�%�j�_'������2a�.�* �:!8	9�E��
�`�mK#�L�~`q!�l���N@��;(-Se@@i��b�]��Lu

�e��5rA�s3U���&V�
��TP`��X�<7SE@@���a�Y��L�
Ef���bA�s3U���V{
��TPh�J���`!�m��R3��� ������T�����f�(7S
lS
��� ��L��(xj�
���3=��BA�S3=(:����S-��'Q�}c�����h������[�Qg���:U"�2MiNi���f�8�0����T+;l�G����sN�6������=I�)�FB@��T���.�����M�! 
p��;��v��:!$�rI�����:������H�JI,<I��J-B{tg�s�}r��&�����}�0�O����3e����V��s�^��b{&0O��Y��O]�����i������L`��&�^�{ez0����M^�L`��"=A@o���R����3���,`Y�:L����~���'�����+a�G�0�=�k�j-T�5��=@@�}��k�|u��j?����e�L`�#=@�V��w&0E��&�39���t�f��Z��S6�hU\��H&��c
�]�&9�������^���p��h����z��6�FkB��	�d��7Gz��M����>��G��M��oL��8��#�M��

[4.D_L��.f�3�1��y�����o��@�-��{ �3ge# `B��3����7�a��B!��Q��

{�?r&
�A����x��_'�1��]��'�`��������uB�2a����F���[�\���6I��r�h7�g
w

G.�@�!]Z�jtH%����nFt^'�����@��fFtY'�A&�X�gD�uB  ��`�����o/�(�	��6"��D��]����pB��Ll8������p�0���_��,8�����B4
pb����	��8(������p:��t0�3���:s
��l ����Gg���U�	���	@�/�3[��OH%�rc�/�Q��fvB*Q&���#�>��0gA-��Tx3�~��
���e��_@��W�}����A��D�����?����a�����/���}7�N�&8�"zD��!����y_���N��0?
�aq��:�S���`n �$^��S��dnxT�������LU
'�3��f�&Sn.`�����w;�N��ri��8��/m��aE���OBZ����;!�@�d�1|�@@�x��7L�SG��!�
 ����;�w����T-�@�w��G �2�8��89g.�)���.�_�q���9���^���@���1]��nvR�O����V�#!����_�rN��Y�}�n��.

��E��#���������X�a
^E$
�I�w�������<,T���L��NKu5iV��������1�2�
�gh��sR���;\����N�
����R]��M7�����e����� �,���_@��e�
�6����&�p�@{^�&�G���P��+$�T%p������3���0��L_^f�T#p����h���>N���&�!���L��9�-���7S�@���>��T#��qo
���n@��e���

!�NRC���j����^@��e��yqk
�����!������j�<-n-`���;SU@��v�p'����������jn���W�5�Lq�w���=S=@�m�������S����M��R��L�
�ha�R����!��*qw
��F5z���~��$���rpl�\�1y���0CW��Kw���cN6����?���	��*��������{��5h>��3Q�C�,gqw
��^���l�RzD�
3�����	��+8�����Bt�S
W
���m��]�	�e�:!���@
7)�m8;�[�
'!�@����9�SeB��9���g*�3�6�Z����Q��N.D/

{Vk���D��:!���2�]���/S@���S�O��|.q��j���f�G0�Rq�
w�F��
?����G�!`�U&�4p�dL�?�d��|�����O���\�����^��z<�����:
k��:
n. z��
��i�B��9���\@��!
��4%_�7�Q ��m�a��������]@m�O��bo�
�lz.��B�1.u���B4
�4)?��j-\�h�P�~�U��j��11�����\ �7�gD��

/6���(�T �hR~Wpu�i���4������6)���P.�����I9Q��r��_^�$�M��2=�����
� nR�s��/��.YC��+���I��9���dT��F_@	�6)7�8����(a�&�^i�����U(a�%�����0���Ch���9��Y

/FB
�7�,*R'������Q��
*��x�uBzD���"� nP�!�W��x�!C/��7��	Y5�C@��4 d����b-��~X��1���2�R�������3�)/��?���~��Z
����B>��hv����B>����v9�|
��3�r*�2#h���2#h����"i�%�2
y�4��j����sQ��@@VD���bz  '��\V5�YC.�����VN
2"l���S��|Hpi�d  �\Z=����WP�!n�����\�ny5�y�-���!p��
�8�K��\Hl�5A@&$���  "�ZdQ��c-�*����nd�
9�8����  :!�.b-�:!i]97��

/Gb]�Zt��e��C�D
�D�@'$�E�E�N�M�����"�|1
��q�H,�R�~���;�j�R!�(���	)+u���b��\�XO�h(���+��k@$sAbe��2	['�K@���!�4%�s�j �X����
�_���2`��_���B�X��7�
�P�d���W��B�X�,���)���_���"�:�X(��R�����2�Xd	,���(�k�q`�H������*�5��6�L$
Y�Db��	����4�P�
YE`��	���
e`�����k�5�a`�,���"+�5�-]`�����*�p<d"pd�X&d	,�eV%���O5 v�uB@��BXgM~��D"p\�X(d	,��V$���O3 ��+��,��"��z�z�ID���B`��%�P���E���	��3��S��A���ZY����ll��
���ha���V����`@��o��Et�^��bY�p�����=�Z~���GD��� �Z-��Q#!����O�q��+����#:��r����o��+�	��a��*!h������6���+�C����r���=�
�9�>�rB�up	(o8��W1���h�5gdZ���
����\��E��\��so:��W*�j��,q�"���8��yc�yEC@��R�W4d�+yE?^���|����5���������.��;�{@���*��

Y�JE^�p�
��W
Y�JE^��p����W
Y�JE^��p����W
Y�JE^�Op��

�������,��7^
d�+y�?W�u����7���W;��+q�?V���4��W*����k�hx1�'�T���P
W���bx�0V9?�o�P��mE�/��L�2a���T
����bX������	�~�%��������C��;�j���6���M�-&};9�1
O�]���8{D����&op90�2V�S\^�����$h2�V��=���I���8��N��py���e�b�B4�1u+�t���~!b�xy�,E0�T��CR��p0�v�H������`�{#�R�D���4���(OU�Q����V��]�C
�`$c��j�`��I��)�����U��	����*��E
fT�!���]0�1���YH��hE����+!�_��������L�H�>X��|�"���SSTw�,Q��N�=A0��c@���Gp�s4XM�!���}���1x���y(��-�x�;�����rCUX�R46�	����p�!L�
��HLg��h�\��\
	���"�y�'��!XG/q|��b�|�1�G
�g�i����h�^@�1��(�`���P�Q�s�3	��$����v�$�IH3H29�,@4I����&��x��p�x�n4E����X����d���TC0�����'�W~{�`���
yl�
}���4����f�1	����������3����.��z��V\F4#
�* ?����Mz��
��	Z0������v	��I�
��jU�%����p_p�nd���*?��t��-u�p��Uz�H�N<��hP��yp�&��M�D�w�����?���#��#+R=�=�����]~\M)r7��OHOc�[�'�BT�{�$`�/Z�	�&���+����]����J��G����	y���t��4E�lX����n�&v,`n�u�������0M�wz�,71k��	�[;���34��n]�/�>=���s��� ��g��8l�7)���0����I�/��q���4X��������?���yh��E�)Xcu[��&z^�n��I�;L��C�-`����f���+C�����4e�;
�?���Y���n2�\�	�b��H�=����Z����|D���i7��{�|�%l��4
����O��>����H�������t}���m�U>I��Yp:k���m"[<&w
z�w�	��Y�����%R�z���]�3N����6���8[><�
���:�M�]l�=j�`�\��-�E8|#wB*�P�]��	�B
w�����2p1�kl��P,IEND�B`�

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index fad5cb0..28984d0 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1417,6 +1417,36 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written it (but not yet
+      flushed it or applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_write</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written and flushed it
+      (but not yet applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_flush</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written, flushed and
+      applied it.  This can be used to gauge the expected delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_apply</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index f23e108..dffadb5 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -11519,6 +11519,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 {
 	static TimestampTz last_fail_time = 0;
 	TimestampTz now;
+	bool		streaming_reply_sent = false;
 
 	/*-------
 	 * Standby mode is implemented by a state machine:
@@ -11842,6 +11843,19 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 					}
 
 					/*
+					 * Since we have replayed everything we have received so
+					 * far and are about to start waiting for more WAL, let's
+					 * tell the upstream server our replay location now so
+					 * that pg_stat_replication doesn't show stale
+					 * information.
+					 */
+					if (!streaming_reply_sent)
+					{
+						WalRcvForceReply();
+						streaming_reply_sent = true;
+					}
+
+					/*
 					 * Wait for more WAL to arrive. Time out after 5 seconds
 					 * to react to a trigger file promptly.
 					 */
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 38be9cf..60047d7 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -705,6 +705,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 7a40863..8be8391 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -188,6 +188,26 @@ static volatile sig_atomic_t replication_active = false;
 static LogicalDecodingContext *logical_decoding_ctx = NULL;
 static XLogRecPtr logical_startptr = InvalidXLogRecPtr;
 
+/* A sample associating a log position with the time it was written. */
+typedef struct
+{
+	XLogRecPtr lsn;
+	TimestampTz time;
+} WalTimeSample;
+
+/* The size of our buffer of time samples. */
+#define LAG_TRACKER_BUFFER_SIZE 8192
+
+/* A mechanism for tracking replication lag. */
+static struct
+{
+	XLogRecPtr last_lsn;
+	WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE];
+	int write_head;
+	int read_heads[NUM_SYNC_REP_WAIT_MODE];
+	WalTimeSample last_read[NUM_SYNC_REP_WAIT_MODE];
+} LagTracker;
+
 /* Signal handlers */
 static void WalSndSigHupHandler(SIGNAL_ARGS);
 static void WalSndXLogSendHandler(SIGNAL_ARGS);
@@ -219,6 +239,8 @@ static long WalSndComputeSleeptime(TimestampTz now);
 static void WalSndPrepareWrite(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static void WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+static int64 LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
 
 static void XLogRead(char *buf, XLogRecPtr startptr, Size count);
 
@@ -244,6 +266,9 @@ InitWalSender(void)
 	 */
 	MarkPostmasterChildWalSender();
 	SendPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE);
+
+	/* Initialize empty timestamp buffer for lag tracking. */
+	memset(&LagTracker, 0, sizeof(LagTracker));
 }
 
 /*
@@ -1495,6 +1520,10 @@ ProcessStandbyReplyMessage(void)
 				flushPtr,
 				applyPtr;
 	bool		replyRequested;
+	uint64		writeLag,
+				flushLag,
+				applyLag;
+	TimestampTz now;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
@@ -1509,6 +1538,12 @@ ProcessStandbyReplyMessage(void)
 		 (uint32) (applyPtr >> 32), (uint32) applyPtr,
 		 replyRequested ? " (reply requested)" : "");
 
+	/* See if we can compute the round-trip lag for these positions. */
+	now = GetCurrentTimestamp();
+	writeLag = LagTrackerRead(SYNC_REP_WAIT_WRITE, writePtr, now);
+	flushLag = LagTrackerRead(SYNC_REP_WAIT_FLUSH, flushPtr, now);
+	applyLag = LagTrackerRead(SYNC_REP_WAIT_APPLY, applyPtr, now);
+
 	/* Send a reply if the standby requested one. */
 	if (replyRequested)
 		WalSndKeepalive(false);
@@ -1524,6 +1559,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLag != -1)
+			walsnd->writeLag = writeLag;
+		if (flushLag != -1)
+			walsnd->flushLag = flushLag;
+		if (applyLag != -1)
+			walsnd->applyLag = applyLag;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1912,6 +1953,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLag = -1;
+			walsnd->flushLag = -1;
+			walsnd->applyLag = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2237,6 +2281,32 @@ XLogSendPhysical(void)
 	}
 
 	/*
+	 * Record the current system time as an approximation of the time at which
+	 * this WAL position was written for the purposes of lag tracking.
+	 *
+	 * In theory we could make XLogFlush() record a time in shmem whenever WAL
+	 * is flushed and we could get that time as well as the LSN when we call
+	 * GetFlushRecPtr() above (and likewise for the cascading standby
+	 * equivalent), but rather than putting any new code into the hot WAL path
+	 * it seems good enough to capture the time here.  We should reach this
+	 * after XLogFlush() runs WalSndWakeupProcessRequests(), and although that
+	 * may take some time, we read the WAL flush pointer and take the time
+	 * very close to together here so that we'll get a later position if it
+	 * is still moving.
+	 *
+	 * Because LagTrackerWriter ignores samples when the LSN hasn't advanced,
+	 * this gives us a cheap approximation for the WAL flush time for this
+	 * LSN.
+	 *
+	 * Note that the LSN is not necessarily the LSN for the data contained in
+	 * the present message; it's the end of the the WAL, which might be
+	 * further ahead.  All the lag tracking machinery cares about is finding
+	 * out when that arbitrary LSN is eventually reported as written, flushed
+	 * and applied, so that it can measure the elapsed time.
+	 */
+	LagTrackerWrite(SendRqstPtr, GetCurrentTimestamp());
+
+	/*
 	 * If this is a historic timeline and we've reached the point where we
 	 * forked to the next timeline, stop streaming.
 	 *
@@ -2686,6 +2756,21 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+usecs_to_interval(uint64 usecs)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+#ifdef HAVE_INT64_TIMESTAMP
+	result->time = usecs;
+#else
+	result->time = usecs / 1000000.0;
+#endif
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2694,7 +2779,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2742,6 +2827,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		int64		writeLag;
+		int64		flushLag;
+		int64		applyLag;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2756,6 +2844,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLag = walsnd->writeLag;
+		flushLag = walsnd->flushLag;
+		applyLag = walsnd->applyLag;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2797,7 +2888,22 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			if (writeLag < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(usecs_to_interval(writeLag));
+
+			if (flushLag < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(usecs_to_interval(flushLag));
+
+			if (applyLag < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(usecs_to_interval(applyLag));
+
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2811,12 +2917,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
@@ -2884,3 +2990,140 @@ WalSndKeepaliveIfNecessary(TimestampTz now)
 			WalSndShutdown();
 	}
 }
+
+/*
+ * Record the end of the WAL and the time it was flushed locally, so that
+ * LagTrackerRead can compute the elapsed time (lag) when this WAL position is
+ * eventually reported to have been written, flushed and applied by the
+ * standby in a reply message.
+ */
+static void
+LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time)
+{
+	bool buffer_full;
+	int new_write_head;
+	int i;
+
+	/*
+	 * If the lsn hasn't advanced since last time, then do nothing.  This way
+	 * we only record a new sample when new WAL has been written.
+	 */
+	if (LagTracker.last_lsn == lsn)
+		return;
+	LagTracker.last_lsn = lsn;
+
+	/*
+	 * If advancing the write head of the circular buffer would crash into any
+	 * of the read heads, then the buffer is full.  In other words, the
+	 * slowest reader (presumably apply) is the one that controls the release
+	 * of space.
+	 */
+	new_write_head = (LagTracker.write_head + 1) % LAG_TRACKER_BUFFER_SIZE;
+	buffer_full = false;
+	for (i = 0; i < NUM_SYNC_REP_WAIT_MODE; ++i)
+	{
+		if (new_write_head == LagTracker.read_heads[i])
+			buffer_full = true;
+	}
+
+	/*
+	 * If the buffer is full, for now we just rewind by one slot and overwrite
+	 * the last sample, as a simple (if somewhat uneven) way to lower the
+	 * sampling rate.  There may be better adaptive compaction algorithms.
+	 */
+	if (buffer_full)
+	{
+		new_write_head = LagTracker.write_head;
+		if (LagTracker.write_head > 0)
+			LagTracker.write_head--;
+		else
+			LagTracker.write_head = LAG_TRACKER_BUFFER_SIZE - 1;
+	}
+
+	/* Store a sample at the current write head position. */
+	LagTracker.buffer[LagTracker.write_head].lsn = lsn;
+	LagTracker.buffer[LagTracker.write_head].time = local_flush_time;
+	LagTracker.write_head = new_write_head;
+}
+
+/*
+ * Find out how much time has elapsed between the moment WAL position 'lsn'
+ * (or the highest known earlier LSN) was flushed locally and the time 'now'.
+ * We have a separate read head for each of the reported LSN locations we
+ * receive in replies from standby; 'head' controls which read head is
+ * used.  Whenever a read head crosses an LSN which was written into the
+ * lag buffer with LagTrackerWrite, we can use the associated timestamp to
+ * find out the time this LSN (or an earlier one) was flushed locally, and
+ * therefore compute the lag.
+ *
+ * Return -1 if no new sample data is available, and otherwise the elapsed
+ * time in microseconds.
+ */
+static int64
+LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now)
+{
+	TimestampTz time = 0;
+
+	/* Read all unread samples up to this LSN or end of buffer. */
+	while (LagTracker.read_heads[head] != LagTracker.write_head &&
+		   LagTracker.buffer[LagTracker.read_heads[head]].lsn <= lsn)
+	{
+		time = LagTracker.buffer[LagTracker.read_heads[head]].time;
+		LagTracker.last_read[head] =
+			LagTracker.buffer[LagTracker.read_heads[head]];
+		LagTracker.read_heads[head] =
+			(LagTracker.read_heads[head] + 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	if (time > now)
+	{
+		/* If the clock somehow went backwards, treat as not found. */
+		return -1;
+	}
+	else if (time == 0)
+	{
+		/*
+		 * We didn't cross a time.  If there is a future sample that we
+		 * haven't reached yet, and we've already reached at least one sample,
+		 * let's interpolate the local flushed time.  This is mainly useful for
+		 * reporting a completely stuck apply position as having increasing
+		 * lag, since otherwise we'd have to wait for it to eventually start
+		 * moving again and cross one of our samples before we can show the
+		 * lag increasing.
+		 */
+		if (LagTracker.read_heads[head] != LagTracker.write_head &&
+			LagTracker.last_read[head].time != 0)
+		{
+			double fraction;
+			WalTimeSample prev = LagTracker.last_read[head];
+			WalTimeSample next = LagTracker.buffer[LagTracker.read_heads[head]];
+
+			Assert(lsn >= prev.lsn);
+			Assert(prev.lsn < next.lsn);
+
+			if (prev.time > next.time)
+			{
+				/* If the clock somehow went backwards, treat as not found. */
+				return -1;
+			}
+
+			/* See how far we are between the previous and next samples. */
+			fraction =
+				(double) (lsn - prev.lsn) / (double) (next.lsn - prev.lsn);
+
+			/* Scale the local flush time proportionally. */
+			time = (TimestampTz)
+				((double) prev.time + (next.time - prev.time) * fraction);
+		}
+		else
+		{
+			/* Couldn't interpolate due to lack of data. */
+			return -1;
+		}
+	}
+
+	/* Return the elapsed time since local flush time in microseconds. */
+	Assert(time != 0);
+	return TimestampTzToIntegerTimestamp(now) -
+		TimestampTzToIntegerTimestamp(time);
+}
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 997a551..51a978d 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -1776,6 +1776,20 @@ GetSQLLocalTimestamp(int32 typmod)
 }
 
 /*
+ * TimestampTzToIntegerTimestamp -- convert a native timestamp to int64 format
+ *
+ * When compiled with --enable-integer-datetimes, this is implemented as a
+ * no-op macro.
+ */
+#ifndef HAVE_INT64_TIMESTAMP
+int64
+TimestampTzToIntegerTimestamp(TimestampTz timestamp)
+{
+	return timestamp * 1000000;
+}
+#endif
+
+/*
  * TimestampDifference -- convert the difference between two timestamps
  *		into integer seconds and microseconds
  *
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index bb7053a..c1e9d4e 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2772,7 +2772,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 5e6ccfc..3ec7dfb 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -47,6 +47,11 @@ typedef struct WalSnd
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
 
+	/* Lag times in microseconds. */
+	int64		writeLag;
+	int64		flushLag;
+	int64		applyLag;
+
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
 
diff --git a/src/include/utils/timestamp.h b/src/include/utils/timestamp.h
index 21651b1..765fa81 100644
--- a/src/include/utils/timestamp.h
+++ b/src/include/utils/timestamp.h
@@ -108,9 +108,11 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time,
 #ifndef HAVE_INT64_TIMESTAMP
 extern int64 GetCurrentIntegerTimestamp(void);
 extern TimestampTz IntegerTimestampToTimestampTz(int64 timestamp);
+extern int64 TimestampTzToIntegerTimestamp(TimestampTz timestamp);
 #else
 #define GetCurrentIntegerTimestamp()	GetCurrentTimestamp()
 #define IntegerTimestampToTimestampTz(timestamp) (timestamp)
+#define TimestampTzToIntegerTimestamp(timestamp) (timestamp)
 #endif
 
 extern TimestampTz time_t_to_timestamptz(pg_time_t tm);

�PNG


IHDR�
�,�
;PLTE���������������@��Ai��� �@���0`��@�������**��@��333MMMfff�������������������22�������U����������������d�"�".�W��p��������������P����E��r��z�����k������� �����������P@Uk/���@�@��`��`�����@��@��`��p������������������������|�@�� ������???������___'''�sV��^:7	pHYs��
�+VIDATx���	��(Ee���E�r�+h�!MG�@}����U� ��
 ���]	�Z�P�?��t�?]�����B��x3Z�dD�Z�����/E	���8yP�P�����S�l�$��
�SE�I�z�2�=������4ehs�9	�G����&
�js"��3E�i�$����� +\`���lw�  p�i�"C@��0�s[a��B���bm�m%w�rD
�/�n����[	����-����
��a[�V]S�
a5
hE�p
��~#���%���:7
�?�$>m���
9]W���m�����q��|��
�
U�����������
V���]$h�1���1����q6��F5���
X�'%�����%
�iv����Y���}4�
�o�A@��
AV  �
Y�� +d�m#���������A������
�$t��l������m4�>6��p��v�R  X1m
'
���f ��s�c0`f%���������q�Xo
�ZZ��i��`�Z�~�k��(����l��px"]w�~O��$L������5��! H�$`W���y�U�M��A@��$`o]���R��>:���@@��
AV  �
Y�� +8�3G  �
)03`��
�a&����e�
��|�yu/���?�jM<O>,��/��a�2���QXf��� �W�(���e�9�)%���G|z�5}0��v���A�"����)��PU���~?�qX�j���;!`"���5�������Q��!`"��*�z|E�=��?H�=�90,�Bl�C�����a����������@�X��P����hE*b����`/D7�#�!`l��w<0��X�i���Gr
^�E(Hk�e���
�p
�WM)������lu�-`:Q{��
H���I�
HB�4���A@  M����z�"�f�6�\��@�k  !zu��^�!��4^+ ��K����7x8$�N�a����^�'���|�<��0p�)�S��DL�Ys�*�x��lO3����|������@�+�U��D@�+  +�
�
��
�(C@�i���|���9���������
3�

?�+����
/���@���9����v3�
�
	��

����i����" �sQ�� `n  ]�] �9�.�.���^��4@�S  �
��Y��0+����! 
��w�9�	f����
�	��99�cH<
B��@@��W
��fB���w�c\���
+�XA���#�^.�t.z����
���}

�Q���p�
�q��	
��/��o-��HG�h���x���!`. �f��{o,��(�	
�_�q����������p�^���w�)��MnwA���Nj��@�} ��� ��E�4M�������	��F��S��Zy�����p�Y�yu�Q����e���,@�	?A��#>��V����@�	gAt]UJqz,t��o����K����i:�}k��@- ����&�� u�����l�Zb��q�/(����!��]
g��]�x��H��G�&1���w�^����p���%���z�3�D���bw�[

�9�
����W
!���}���[qNb�\�&H�u��;���}�@@-��Ra��������@���
��X�FA�
^
'������
n����w��j�Vy���[ ��wA:{���p��h
]
��*u5p\���0�
(].Dox�����0��v��,~z��^��BR:�[x>�x���
�B@�nM! ����B�RC��1�!��F���/� �)�^��Rt��W!^6�|�:-����/R>�{-�@��)�#���g�0�h�
�D@iw����0�h�
�C@%�n�<y*n�'	x�v�{��O!��8+�z�x��0����={��ui�#�!`h��b��1"F:+����
�vo+���o���GDC��Hg�<���t�}X1��(R&��>p����b$KQ�(L��,��Y������,E��0
q0R�@� ��B��@����������RT�d(L@\���P� �L���u@���"\.>Cq�z�_:1=��P�����_�
�yH���0 ���"�Fg(L@3 U�2��%����P��b��������3
K���xH�����~�]�R�W_�~������v/�(��XfA�c&����k
�Ec�&`qS�~N~������D{
�
�,�3�G�
�����=���	�9��?�G����6��on�b��������n+�o��yU��U��b|,�|��=��Q��t
�Km^�������������P����b#��
�#�%`������uD��t��Y��������r���t������

!�)���F4�5
]-��0����{�y�,�Nd�S����������0
�S:���tF� B@���a�&��u%�j��K��n��$�!���$A�W�y����.��Z����Ln
���%`=�t'b�.�.�.�
t���u��9����o��
x�$R���
8����j���(d�����F��gD���}���48����O@�J���.���)zOG����A5����Tz���6�����h��n��a���2�e���TL��=��{i���N��V�(`��7��	8�������$x|�pP��*`�K��	8�95�����6���(L@��\�eB��
\�����IH'�f{��*���,O�|�h�%`�+3�����_"`��e	(�r���_�,
�5��g
���8��8
�*T��q��zW�P��B3Y�s `�����������
3,^���\3����4
��S������Sq0��	(p���
��C�p�8�_qC
��
��wj#�^8�j��u���@@�:�|GX�;~�c����
�//�+�R��NHQ����7A��������a���t"
��k��8������^@���B�`fF��L6
#��E��v�HgFH'$��>��eI�
-��x�
�/��xB
���ZO@I��6��U��h��3`f��G@@8�*�=
GZ�7z��'��~��0��	�j!6S@�?����j9��)��,���L�P��3���p&���� `0>3#��q�?�F���U�V�n
U�-�{#s�������� ��/DC@8"�\��"�w�W
H���/DC��h�u(K�I��oL�h$]��Gb�y\"q�C$p,�x8V
�
�Q�����:�YpZ
��t
A�F7A�I��K;K~b
'���k����!�
������_�]|����X�
)�P���
S��^��-#��u�X,����0<��j����.���^����U(J��B��T��Bc$0G��
���kl�*�&�����1���W�$Y}#��
�SE�^@%�nu�!��:Ud�� �_E�r@*�NU*"Jz
������x�1z�DH(�[�
�~n��+�PD�z��0��0�%WD��(L>7�o! y
������C�!�S��2Qa�X��D��
	�q!������������n#$�@Q��������?QV���	�V �s�^^�n��P������1�& U��t��\�����  e��i����E5
�0���:QJ�H�:;.����:�����JD��"��K��z}�R�V
]h��:`�!���:�A$���r\MR���
]s�ME�<�I�������U��I���_��?51n�D-]������r�r5����/���d��ueNR
�sy�*��I')�����s
H��(
SNR�DH��(
SNR�A@�S�GH��"')�������H�K@���/l"�N]��	'��������H�K��Tf0v��G@��8Aeh! u��L7A%�H��%I�l���A����P�����7
F.��S���M����!`�!�{8�� �Z}���-+N�A@�p��%�#��:/,~���H�V_" C�J0��,t�
Y�������y!`�E)�*B@�L
+L�#Z �k@���S�O
S,K�V!`(:gz��Q-����X�
�" CV�`a��

C��1)��@@�0���7O� `T��(YdI��Yo�h�B�P�)�g�]n�AIF��G��,tM����
8*��Z����	
}p_|��N��������c[�) �����X@J�/ W�  	�dJ	
}�����/`t�p����@@/ [�  	����
�����\#@@�L��(H�B���R��d7�  [&�&�" ��-!��ez��L#R$<��<
[�>
YV&��N- _�7H�6����A��M����k

} P��/�a|8�����ms��� �����%�RB@���dm��m[yH�6�`��l9�����_  k��������M�����7�^|�l�	4�����n-��!xn
��v��|�;�N�h����!�9�n�U<���O����
z

Y�I@���
��,� �+
��*A�M��]o�7��$���@@�D��y��	�)%M�d
��B
�sA@/  G"��i�]�&S
I�C@�d)�:?T@�fA@�D����	G�@@  y�t�g��^��L�U�rA���,���� �3�Atsb�
�����$z��<���� �3�Q�{
�
�s�0Q��( S���&�)
$��,
�����M�0Q� �;qS�����>d��I�!t�5�#U����� `(��k�aH���x
���\�d�z���
��7L
�sC@  yn���L�Q�L���	�����0.�a<UGA�P  y�G	������/���)�DO��=��	����@@��)�r
������g��	@@/  5O��9������a@@���H�z�T@��|��

�sC@/  un���

�H) {c  5�����@�0  u�D����dy���=S��3<���	��^����~�rX2���������>�����}�*�<.~����K
B�[�x�j~���v5R��P@%T+E{���[�����������j/m��=pS��4�^����b�����}��C%j��u���tG�Wm�+�m@\���\[�S��c��f!�E�X���l�Z�H��������Q-���/8�F:
[av��>�?����j�u���p��0}y��Y_�����~��J@A�����_�\4���>e^�7g��G'��{_�����aE@�����#��Vu�z��w�����/*��|9���>�:����vU�/����R�o���x.#.��Z�����#���fs��q%'���J�P����'�|})�7�W����V��p
���'!�����2���
@2�n�
���AY�Z����jB�F�{E�������`�?���J�{#M�Md��R
�C������J����>���K�����c=t5Ox-����m0�Z7S��#+1X2���?���J��1R����Y����G����#k!���>,]�)�WW
Q���Y�����'}h-�c@��fl�#�����dK
=������yx���#�2������Em.
����Bs	��X2�ph��%��p$/o* WW����
Kx{�\!t��=�Yt#Yd{jm:�a},��?	���Cp���v�TG�Sh�NBC�a��9*�uR��u�� ���\�mt���|�8��y����%sX��Ch��d��h7���y.D��k�]�M�G�l�'�y�������7����:��Y,7�$��8��+
J�>��H7��m����G�u���|	!6�y9�yg!���J�W�%`�
\
��q����ra�r�f�L���o)�t��F���C��P�x��E����0�6�������[$�Qx-�����lF�����G���������5�YN���im'�[@#`����vQ�0l�6a���[7Nx`C��C�i���G���v�����@U�2�0;���-��"�Z@;��8��\�b�ja�����1;_\oJ�����?�y6
�F����g0{���zYj���[h��� �\�-�a���4����q��"���l��V��O�Fj�T��E�f�K
3��s
���� �6� �8u���c�q���T��y�&;������_��+L��\^7�O��8l
�E*l
��|�0t�9��Gd�4:}����1`�'����Pw�L�0?����?	�p�d��+�D�=��pN��	����T�����,��5o��5X�w��I{�g���S�y�?����1���"��9����F����w���z�y�
�-[�����Y]��-��`^�
_��m��od�N�!0�^0����
4fA�h�
��ew�#y��IEND�B`�

�PNG


IHDR�
�,�
;PLTE���������������@��Ai��� �@���0`��@�������**��@��333MMMfff�������������������22�������U����������������d�"�".�W��p��������������P����E��r��z�����k������� �����������P@Uk/���@�@��`��`�����@��@��`��p������������������������|�@�� ������???������___'''�sV��^:7	pHYs��
�+�IDATx�����*Ee���!������'��������$���� bU
����&�����6�"�7���K��u�EoFc�`R"E�%�f�Xp�[{`�m"�c%?%��h�~������&��:|������&��j�~����������I���!���l�\���A��J�����^�j��a�T��w�Z����US
�7R�nu�^W��0Mc�
�P����&.�o���k�VWvCX�:�{C@�����Z����:�F
�G��[��F=����h�lz��0�S��a�4V���J�ZU+
Y�w��`E
��G��]����y�c�(����~T�I�2����D  X#��V�57���G�H~I��@@��
AR  ����S&3��>  ��� )�s�J�_
����T�������9�\/b38��
�8���~7t@���w��^n[E?33�[�I����v���Dg����f���������A@0��TJ:���@@0�-`��u�cn�����F��l8��n�~?���/c��$��|��]���

/+
[�4Rh�����n��������u������������L@@��
AR  H
I�� )��tG���I�� )V9;�P��b|��/�*M�+��n���	!;{c�}�/d5��&'�R����������������	�K����mcM�F	���i�f���]pS�Z���L3���^��y[���q��:�9tV1-���N@3l���uK]�����Q(� �z���
7������$��)�-��P����������#��c@�[��
���S
R�[�~�%
�C��e;B����z,\�N���95���.��1�c��Cj����hu������94Dk���n=K�=������a�hu
D�^�����,0�<G���q]��(4�<�s
�WM)H��@c���tq:R
Ro<�>���"�

AR  H
I�� )$��@@��
AR  H
I�� )$��@@��
AR  H
)��
��@@��
AR  H
I�� )$��@@��
AR  H
I�� )$��@@��
AR  H
I�� )��W7"R���{�f�� ��z�6|X��!�C(@�Vo|
B
j���|�����j�2>�t���|�h�����
H! �5�����[�a����b �Cx���V���l���6 `�*�j�|p�7�$\��� %��N�hd�[i�'�|t�:e.`#��;�����F�Xy��F�zh�kj�s�q?��x
�r�k�z����t���iN>�'!/�
M����0p�-~�Lt�	�1�^���4��
u[U�m6�=S�6����9�������u7h<�����V�Nt���'��g�|�E!jiT���~�����?b��I��^�Zw�"�L�"`����'p�m�<����d�!�p�P/��l�!`��Z�V�J����n���tW�'�� �`������}s0���t\o�c��It�N���j8�5[C`Q�Vp:3�w��n����

�r����Z7���! L�=�2������
!`R�0�|pDQJ4D?���%`+t�`��%�o_|�|@�]�2�9�S�������%��t0�jn����b�)PS�����]���3a����d&�t;`�C@�����4���+�)�&�8*��#1)�
-��%�X�O�h)N@��~��%�D��'Q����(
���I��~$�d&�����(��>p�
p<np�h��K�k��j����)(Q�K����,&��������I;��m���	(R�+��Jb�
T�d&`�����'�0=d��&`o���������&3
k%Du�!ux�Rp>��T
k���:���Z����	�`s���,��m���R�Q3����>L�|1��/�-�X�����������K>LI�J!�8��

B-L^��e�;V�. ���r_r��x
�Q����������s@�h.�p��i1Ft��������L�����r�t
�x�
fJ�jil#_�]p�0����F�~/\at�L)^�^��O>�
�,	(�Q���.`�������q?��p
+����ih��^{aWr�W�w�?���#�p�A�xLC<B��<X<;K.�
�� `
0�-@@p�G��
����03�����d|Y�V���C���S4��%�d��#��v��2x7��G����#d'S
��<v���W>�����M
�Mv}l�U�^�����T��3���)��q��h?��e%3
�Guy��
}9Xs/p�sh�����}��d_��cp"mQ�-���5Y�;����m����������P��v�o! /ex}N���|xX!3p���p����{���Yq�nZl
Y)C@�}�][t��(�xFH�
�(B@��.�
��oY ������~�
����@@/  5��"��
f��p�� �?��"���R�1z%�
���N$���������u��������FF������	C@NW���)`d��<<�p�p���.�����)O? %+
?##�#o���x��7�FFh��1��f�x��
{������p��48�����Za�	�)GS���Q�����F��qaZ|iG�l����{F �!��+
�g�.H�����}���8��grS@^���m-�C�z��$X�

��]]o��%N�a����52���#��'���[�[@B ���Bq���F�W���
����/�{�;����}#?[��w��
3�&`��\dR��OL��l3x�Wg��n�g����p�Pj-����g��m���4��m�r�|��������
�#3
C�� �y���_�[��Hw��.8`�7	��kO���$���&
����o�9�����\�[<���������4�w����V�G�L>���a���`�����4��8�L�n�U  ����<
!����y�$`-�i�a��[�'t�/��#`P����H�!n����a��!Q��n�u  ���c���?&��<+=,���Kc���
7�z����	�?��}�d�z��K�L�%�8
Cr0pY�����S��$�C�	��h�������?�;x�d����}�&QC4Ww���I��x��	�#�g�A�����F�
po��]�����
��P���}X��
g<�
���������'�����/><��>4���$.~��G4���eR~?���A��A!��M��p����;@��9�0xI()����V� ������&�&�A�7��X
��
o0� ����7	�d���j�4�P�n��@
�$�A�!�q�o0� �{�z���4oy�X��)�@@�V�n��hq�$��{~��V�\���&�%�
*�p>�+O�;�A9@%��2��
�-Jhq7'��p�J�;J������
�	��=�$�i_,�'�)��F��Z��Xr�P�Gxk�!��lX�����[1�����3�.��c��jA@�(���L����Z_)a0�������{��w�
R�^-.|�B���w�.x&nR8���#��T\�4
��_h�I� ��.�����C�+9pI=6T_3�?����n���/�4
��F�?��E���!�.�;zNrH����Y@�6�r�]3��_8��B������!��'<S@^�!!�>�	������50�� ��-�pa! >�
��U�S@�o�\
	j�T
�^F�%�,����+��c>��
@@���}	�??���K�&��:A@��<{�?�_	��K�9z����b�	HP�{��
!�!�n��[,���b�fx�;��V�/��w�% I�n�0\,U@�zA@�Y}
��h

9�i*�rqNHX/�?',T@�J�\��) U�r���\����) Y�B�.�
	�
�$��G@^�$ ]�|����

��J����������q
��A@�|�*h@���N>
���g ����O�C@�*�	���R����z��������,��k��Zm.���  A~:
�J~�����A@�#E_����o
�|�~~:
�J~������\�,�A@�|�#%_���?��_��L�%��^o0�`H���'�<���C����b��.�|F6�RH_1J
k  ��R��! !�!��/�tN>� �
MS�C��Y!�uhOB�d�1�QrB
��N@V�a��k�S0��]@��%
��_Q��������=K�o��b%
��R
�H+`�+�%C@:^*�����f�/��,K�!�{��! �<��N
o
�H)`�>K%���_B
y*
��K���3K		��g��dH��/U@�z�0R�%����g�����v���dF���R4����/� ���_%"	�U�T��`�R4�����
i��]�b)��F��G�e�P@���N@��w3���8/�r1�,
c��~AR4�#��Q�S%�O@��%0�Z�(����eC��|HT6����8J��tD0�JJ$`�����f�,�[�(+i���! �*>~��	�Y���YI��

���D�0��F�/����� �w~B
)��C�n4�]@��E0���4��oA�E3��/�

}����SM/�����8�/ o�"
���G^2�.�Z��3?����t�]���#	�\�x���K@��! �
��y@�;�qW,��Q�[
�Q0$�T
?�(�8���4���`�X��o! K�y8����c8�
I
c�P
'���! ��].��Z�&v����9v�;x�A$
S�����lUy	��Sj��d"����y��0�H��R'�#�V��oS��?�<�e~��7/�w�2pj�"�h�9��w����-���.�����3O��o�����V� �VB��ga�-6��������������6S�b��U����g����Gt `4W%~���!�u#E���������}�y��?�����c���X�����}-��b����b������'K����s��2�
��������q���Uo+������t�_S.�!�����Y���W;~����������&^�N�F���T[����{��u���|��+>X����[����+�r��[�x�s���-
�DQ-�^l��;(���a%�	h���^��'
�^�W~��)�}�v��~ �-`��8.����)�'y�k��i������#����J���j��E_��~+�u�u�_G_��X�����@�m%q����(��;+�u���U��,<"zp��!dn��%��fb��
@4�.�
J��eP*�j�x���!�h���G����F����������V�&3�Ka��6���������'%��1�0��]�;���2tzhO�N@�h���zZ`��Z���t�c4����#O������+��i�'!���>�.��Z�{]Ti��%������6b<����`��8�i*g�K�?E0���U����<��%�X����g�[!��\N��U9Ds	��X2�ph��%��p$/* ���lw�'�Q�%��,�����,V#Y�;��+���X
H�?	��*�p���fh�����m

�IH�=l7�Bs��T��l�r������\�.�>Z��0����=X2�R������y�m��y��	O�k����%[C��6�����RO���]����:��Y,�$��8��*
r���v�v����3���z���%����tr�B@��H�W�%��.�a<l��\��E��Y�Cmh����$�Q<��t�g�����$���t3�o�t����+�]0�R��TE#����m��s��	!7�A����YNS����V,��V��7R��4�i-���'F�7����.��00����H��|��v����3�
�a��j�$j-�kkpk����j;1����y����M��v
����G�pn4u��|���{*%�r�a��v-�;�
�i�$���:����<0�t}�\�8K�'���t����I��q[��������W�T��&�X�qZ7� �o� �8t���c
�,��S�T�����Su5��Q@�+�~��.m
��&���W��-�8K�-`��Ga�
���x��lF��d������s\gQ���U��1�(�W
���te��qg�B
���8��;���r'�r:�g�?~��8�7c��=���Q���y����"g
�#�H;|�h�6�Z17��q�v��������i�yP���U;`5nQ��Y��B|.��p�B���B
������A�a��f1����3��(��IEND�B`�

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index fad5cb0..28984d0 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1417,6 +1417,36 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written it (but not yet
+      flushed it or applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_write</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written and flushed it
+      (but not yet applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_flush</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written, flushed and
+      applied it.  This can be used to gauge the expected delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_apply</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 8973583..40b7b60 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -11499,6 +11499,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 {
 	static TimestampTz last_fail_time = 0;
 	TimestampTz now;
+	bool		streaming_reply_sent = false;
 
 	/*-------
 	 * Standby mode is implemented by a state machine:
@@ -11822,6 +11823,19 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 					}
 
 					/*
+					 * Since we have replayed everything we have received so
+					 * far and are about to start waiting for more WAL, let's
+					 * tell the upstream server our replay location now so
+					 * that pg_stat_replication doesn't show stale
+					 * information.
+					 */
+					if (!streaming_reply_sent)
+					{
+						WalRcvForceReply();
+						streaming_reply_sent = true;
+					}
+
+					/*
 					 * Wait for more WAL to arrive. Time out after 5 seconds
 					 * to react to a trigger file promptly.
 					 */
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 38be9cf..60047d7 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -705,6 +705,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 9cf9eb0..0805861 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -188,6 +188,26 @@ static volatile sig_atomic_t replication_active = false;
 static LogicalDecodingContext *logical_decoding_ctx = NULL;
 static XLogRecPtr logical_startptr = InvalidXLogRecPtr;
 
+/* A sample associating a log position with the time it was written. */
+typedef struct
+{
+	XLogRecPtr lsn;
+	TimestampTz time;
+} WalTimeSample;
+
+/* The size of our buffer of time samples. */
+#define LAG_TRACKER_BUFFER_SIZE 8192
+
+/* A mechanism for tracking replication lag. */
+static struct
+{
+	XLogRecPtr last_lsn;
+	WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE];
+	int write_head;
+	int read_heads[NUM_SYNC_REP_WAIT_MODE];
+	WalTimeSample last_read[NUM_SYNC_REP_WAIT_MODE];
+} LagTracker;
+
 /* Signal handlers */
 static void WalSndSigHupHandler(SIGNAL_ARGS);
 static void WalSndXLogSendHandler(SIGNAL_ARGS);
@@ -219,6 +239,8 @@ static long WalSndComputeSleeptime(TimestampTz now);
 static void WalSndPrepareWrite(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static void WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+static TimeOffset LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
 
 static void XLogRead(char *buf, XLogRecPtr startptr, Size count);
 
@@ -244,6 +266,9 @@ InitWalSender(void)
 	 */
 	MarkPostmasterChildWalSender();
 	SendPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE);
+
+	/* Initialize empty timestamp buffer for lag tracking. */
+	memset(&LagTracker, 0, sizeof(LagTracker));
 }
 
 /*
@@ -1496,6 +1521,10 @@ ProcessStandbyReplyMessage(void)
 				flushPtr,
 				applyPtr;
 	bool		replyRequested;
+	TimeOffset	writeLag,
+				flushLag,
+				applyLag;
+	TimestampTz now;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
@@ -1510,6 +1539,12 @@ ProcessStandbyReplyMessage(void)
 		 (uint32) (applyPtr >> 32), (uint32) applyPtr,
 		 replyRequested ? " (reply requested)" : "");
 
+	/* See if we can compute the round-trip lag for these positions. */
+	now = GetCurrentTimestamp();
+	writeLag = LagTrackerRead(SYNC_REP_WAIT_WRITE, writePtr, now);
+	flushLag = LagTrackerRead(SYNC_REP_WAIT_FLUSH, flushPtr, now);
+	applyLag = LagTrackerRead(SYNC_REP_WAIT_APPLY, applyPtr, now);
+
 	/* Send a reply if the standby requested one. */
 	if (replyRequested)
 		WalSndKeepalive(false);
@@ -1525,6 +1560,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLag != -1)
+			walsnd->writeLag = writeLag;
+		if (flushLag != -1)
+			walsnd->flushLag = flushLag;
+		if (applyLag != -1)
+			walsnd->applyLag = applyLag;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1913,6 +1954,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLag = -1;
+			walsnd->flushLag = -1;
+			walsnd->applyLag = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2238,6 +2282,32 @@ XLogSendPhysical(void)
 	}
 
 	/*
+	 * Record the current system time as an approximation of the time at which
+	 * this WAL position was written for the purposes of lag tracking.
+	 *
+	 * In theory we could make XLogFlush() record a time in shmem whenever WAL
+	 * is flushed and we could get that time as well as the LSN when we call
+	 * GetFlushRecPtr() above (and likewise for the cascading standby
+	 * equivalent), but rather than putting any new code into the hot WAL path
+	 * it seems good enough to capture the time here.  We should reach this
+	 * after XLogFlush() runs WalSndWakeupProcessRequests(), and although that
+	 * may take some time, we read the WAL flush pointer and take the time
+	 * very close to together here so that we'll get a later position if it
+	 * is still moving.
+	 *
+	 * Because LagTrackerWriter ignores samples when the LSN hasn't advanced,
+	 * this gives us a cheap approximation for the WAL flush time for this
+	 * LSN.
+	 *
+	 * Note that the LSN is not necessarily the LSN for the data contained in
+	 * the present message; it's the end of the the WAL, which might be
+	 * further ahead.  All the lag tracking machinery cares about is finding
+	 * out when that arbitrary LSN is eventually reported as written, flushed
+	 * and applied, so that it can measure the elapsed time.
+	 */
+	LagTrackerWrite(SendRqstPtr, GetCurrentTimestamp());
+
+	/*
 	 * If this is a historic timeline and we've reached the point where we
 	 * forked to the next timeline, stop streaming.
 	 *
@@ -2687,6 +2757,17 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+offset_to_interval(TimeOffset offset)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+	result->time = offset;
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2695,7 +2776,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2743,6 +2824,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		TimeOffset	writeLag;
+		TimeOffset	flushLag;
+		TimeOffset	applyLag;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2757,6 +2841,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLag = walsnd->writeLag;
+		flushLag = walsnd->flushLag;
+		applyLag = walsnd->applyLag;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2798,7 +2885,22 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			if (writeLag < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(offset_to_interval(writeLag));
+
+			if (flushLag < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(offset_to_interval(flushLag));
+
+			if (applyLag < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(offset_to_interval(applyLag));
+
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2812,12 +2914,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
@@ -2885,3 +2987,139 @@ WalSndKeepaliveIfNecessary(TimestampTz now)
 			WalSndShutdown();
 	}
 }
+
+/*
+ * Record the end of the WAL and the time it was flushed locally, so that
+ * LagTrackerRead can compute the elapsed time (lag) when this WAL position is
+ * eventually reported to have been written, flushed and applied by the
+ * standby in a reply message.
+ */
+static void
+LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time)
+{
+	bool buffer_full;
+	int new_write_head;
+	int i;
+
+	/*
+	 * If the lsn hasn't advanced since last time, then do nothing.  This way
+	 * we only record a new sample when new WAL has been written.
+	 */
+	if (LagTracker.last_lsn == lsn)
+		return;
+	LagTracker.last_lsn = lsn;
+
+	/*
+	 * If advancing the write head of the circular buffer would crash into any
+	 * of the read heads, then the buffer is full.  In other words, the
+	 * slowest reader (presumably apply) is the one that controls the release
+	 * of space.
+	 */
+	new_write_head = (LagTracker.write_head + 1) % LAG_TRACKER_BUFFER_SIZE;
+	buffer_full = false;
+	for (i = 0; i < NUM_SYNC_REP_WAIT_MODE; ++i)
+	{
+		if (new_write_head == LagTracker.read_heads[i])
+			buffer_full = true;
+	}
+
+	/*
+	 * If the buffer is full, for now we just rewind by one slot and overwrite
+	 * the last sample, as a simple (if somewhat uneven) way to lower the
+	 * sampling rate.  There may be better adaptive compaction algorithms.
+	 */
+	if (buffer_full)
+	{
+		new_write_head = LagTracker.write_head;
+		if (LagTracker.write_head > 0)
+			LagTracker.write_head--;
+		else
+			LagTracker.write_head = LAG_TRACKER_BUFFER_SIZE - 1;
+	}
+
+	/* Store a sample at the current write head position. */
+	LagTracker.buffer[LagTracker.write_head].lsn = lsn;
+	LagTracker.buffer[LagTracker.write_head].time = local_flush_time;
+	LagTracker.write_head = new_write_head;
+}
+
+/*
+ * Find out how much time has elapsed between the moment WAL position 'lsn'
+ * (or the highest known earlier LSN) was flushed locally and the time 'now'.
+ * We have a separate read head for each of the reported LSN locations we
+ * receive in replies from standby; 'head' controls which read head is
+ * used.  Whenever a read head crosses an LSN which was written into the
+ * lag buffer with LagTrackerWrite, we can use the associated timestamp to
+ * find out the time this LSN (or an earlier one) was flushed locally, and
+ * therefore compute the lag.
+ *
+ * Return -1 if no new sample data is available, and otherwise the elapsed
+ * time in microseconds.
+ */
+static TimeOffset
+LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now)
+{
+	TimestampTz time = 0;
+
+	/* Read all unread samples up to this LSN or end of buffer. */
+	while (LagTracker.read_heads[head] != LagTracker.write_head &&
+		   LagTracker.buffer[LagTracker.read_heads[head]].lsn <= lsn)
+	{
+		time = LagTracker.buffer[LagTracker.read_heads[head]].time;
+		LagTracker.last_read[head] =
+			LagTracker.buffer[LagTracker.read_heads[head]];
+		LagTracker.read_heads[head] =
+			(LagTracker.read_heads[head] + 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	if (time > now)
+	{
+		/* If the clock somehow went backwards, treat as not found. */
+		return -1;
+	}
+	else if (time == 0)
+	{
+		/*
+		 * We didn't cross a time.  If there is a future sample that we
+		 * haven't reached yet, and we've already reached at least one sample,
+		 * let's interpolate the local flushed time.  This is mainly useful for
+		 * reporting a completely stuck apply position as having increasing
+		 * lag, since otherwise we'd have to wait for it to eventually start
+		 * moving again and cross one of our samples before we can show the
+		 * lag increasing.
+		 */
+		if (LagTracker.read_heads[head] != LagTracker.write_head &&
+			LagTracker.last_read[head].time != 0)
+		{
+			double fraction;
+			WalTimeSample prev = LagTracker.last_read[head];
+			WalTimeSample next = LagTracker.buffer[LagTracker.read_heads[head]];
+
+			Assert(lsn >= prev.lsn);
+			Assert(prev.lsn < next.lsn);
+
+			if (prev.time > next.time)
+			{
+				/* If the clock somehow went backwards, treat as not found. */
+				return -1;
+			}
+
+			/* See how far we are between the previous and next samples. */
+			fraction =
+				(double) (lsn - prev.lsn) / (double) (next.lsn - prev.lsn);
+
+			/* Scale the local flush time proportionally. */
+			time = (TimestampTz)
+				((double) prev.time + (next.time - prev.time) * fraction);
+		}
+		else
+		{
+			/* Couldn't interpolate due to lack of data. */
+			return -1;
+		}
+	}
+
+	/* Return the elapsed time since local flush time in microseconds. */
+	Assert(time != 0);
+	return now - time;
+}
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index a4cc86d..14ea89c 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2772,7 +2772,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 5e6ccfc..1211951 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -47,6 +47,11 @@ typedef struct WalSnd
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
 
+	/* Measured lag times. */
+	TimeOffset	writeLag;
+	TimeOffset	flushLag;
+	TimeOffset	applyLag;
+
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
 
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index c661f1d..6ebcabc 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1831,10 +1831,13 @@ pg_stat_replication| SELECT s.pid,
     w.write_location,
     w.flush_location,
     w.replay_location,
+    w.write_lag,
+    w.flush_lag,
+    w.replay_lag,
     w.sync_priority,
     w.sync_state
    FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn)
-     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) ON ((s.pid = w.pid)))
+     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, write_lag, flush_lag, replay_lag, sync_priority, sync_state) ON ((s.pid = w.pid)))
      LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
 pg_stat_ssl| SELECT s.pid,
     s.ssl,

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 4d03531..9f96be6 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1425,6 +1425,36 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written it (but not yet
+      flushed it or applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_write</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written and flushed it
+      (but not yet applied it).  This can be used to gauge the expected
+      delay that <literal>synchronous_commit</literal> level
+      <literal>remote_flush</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written, flushed and
+      applied it.  This can be used to gauge the expected delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_apply</literal> would incur while committing if this
+      server is configured as a synchronous standby.</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index c0e5362..f7269c3 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -11523,6 +11523,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 {
 	static TimestampTz last_fail_time = 0;
 	TimestampTz now;
+	bool		streaming_reply_sent = false;
 
 	/*-------
 	 * Standby mode is implemented by a state machine:
@@ -11846,6 +11847,19 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 					}
 
 					/*
+					 * Since we have replayed everything we have received so
+					 * far and are about to start waiting for more WAL, let's
+					 * tell the upstream server our replay location now so
+					 * that pg_stat_replication doesn't show stale
+					 * information.
+					 */
+					if (!streaming_reply_sent)
+					{
+						WalRcvForceReply();
+						streaming_reply_sent = true;
+					}
+
+					/*
 					 * Wait for more WAL to arrive. Time out after 5 seconds
 					 * to react to a trigger file promptly.
 					 */
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 0bce209..eff3c07 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -705,6 +705,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index dd3a936..dfe1ed8 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -188,6 +188,26 @@ static volatile sig_atomic_t replication_active = false;
 static LogicalDecodingContext *logical_decoding_ctx = NULL;
 static XLogRecPtr logical_startptr = InvalidXLogRecPtr;
 
+/* A sample associating a log position with the time it was written. */
+typedef struct
+{
+	XLogRecPtr lsn;
+	TimestampTz time;
+} WalTimeSample;
+
+/* The size of our buffer of time samples. */
+#define LAG_TRACKER_BUFFER_SIZE 8192
+
+/* A mechanism for tracking replication lag. */
+static struct
+{
+	XLogRecPtr last_lsn;
+	WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE];
+	int write_head;
+	int read_heads[NUM_SYNC_REP_WAIT_MODE];
+	WalTimeSample last_read[NUM_SYNC_REP_WAIT_MODE];
+} LagTracker;
+
 /* Signal handlers */
 static void WalSndSigHupHandler(SIGNAL_ARGS);
 static void WalSndXLogSendHandler(SIGNAL_ARGS);
@@ -219,6 +239,8 @@ static long WalSndComputeSleeptime(TimestampTz now);
 static void WalSndPrepareWrite(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static void WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+static TimeOffset LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
 
 static void XLogRead(char *buf, XLogRecPtr startptr, Size count);
 
@@ -244,6 +266,9 @@ InitWalSender(void)
 	 */
 	MarkPostmasterChildWalSender();
 	SendPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE);
+
+	/* Initialize empty timestamp buffer for lag tracking. */
+	memset(&LagTracker, 0, sizeof(LagTracker));
 }
 
 /*
@@ -1501,6 +1526,13 @@ ProcessStandbyReplyMessage(void)
 				flushPtr,
 				applyPtr;
 	bool		replyRequested;
+	TimeOffset	writeLag,
+				flushLag,
+				applyLag;
+	bool		clearLagTimes;
+	TimestampTz now;
+
+	static bool	fullyAppliedLastTime = false;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
@@ -1515,6 +1547,30 @@ ProcessStandbyReplyMessage(void)
 		 (uint32) (applyPtr >> 32), (uint32) applyPtr,
 		 replyRequested ? " (reply requested)" : "");
 
+	/* See if we can compute the round-trip lag for these positions. */
+	now = GetCurrentTimestamp();
+	writeLag = LagTrackerRead(SYNC_REP_WAIT_WRITE, writePtr, now);
+	flushLag = LagTrackerRead(SYNC_REP_WAIT_FLUSH, flushPtr, now);
+	applyLag = LagTrackerRead(SYNC_REP_WAIT_APPLY, applyPtr, now);
+
+	/*
+	 * If the standby reports that it has fully replayed the WAL in two
+	 * consecutive reply messages, then the second such message must result
+	 * from wal_receiver_status_interval expiring on the standby.  This is a
+	 * convenient time to forget the lag times measured when it last
+	 * wrote/flushed/applied a WAL record, to avoid displaying stale lag data
+	 * until more WAL traffic arrives.
+	 */
+	clearLagTimes = false;
+	if (applyPtr == sentPtr)
+	{
+		if (fullyAppliedLastTime)
+			clearLagTimes = true;
+		fullyAppliedLastTime = true;
+	}
+	else
+		fullyAppliedLastTime = false;
+
 	/* Send a reply if the standby requested one. */
 	if (replyRequested)
 		WalSndKeepalive(false);
@@ -1530,6 +1586,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLag != -1 || clearLagTimes)
+			walsnd->writeLag = writeLag;
+		if (flushLag != -1 || clearLagTimes)
+			walsnd->flushLag = flushLag;
+		if (applyLag != -1 || clearLagTimes)
+			walsnd->applyLag = applyLag;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1918,6 +1980,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLag = -1;
+			walsnd->flushLag = -1;
+			walsnd->applyLag = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2243,6 +2308,32 @@ XLogSendPhysical(void)
 	}
 
 	/*
+	 * Record the current system time as an approximation of the time at which
+	 * this WAL position was written for the purposes of lag tracking.
+	 *
+	 * In theory we could make XLogFlush() record a time in shmem whenever WAL
+	 * is flushed and we could get that time as well as the LSN when we call
+	 * GetFlushRecPtr() above (and likewise for the cascading standby
+	 * equivalent), but rather than putting any new code into the hot WAL path
+	 * it seems good enough to capture the time here.  We should reach this
+	 * after XLogFlush() runs WalSndWakeupProcessRequests(), and although that
+	 * may take some time, we read the WAL flush pointer and take the time
+	 * very close to together here so that we'll get a later position if it
+	 * is still moving.
+	 *
+	 * Because LagTrackerWriter ignores samples when the LSN hasn't advanced,
+	 * this gives us a cheap approximation for the WAL flush time for this
+	 * LSN.
+	 *
+	 * Note that the LSN is not necessarily the LSN for the data contained in
+	 * the present message; it's the end of the the WAL, which might be
+	 * further ahead.  All the lag tracking machinery cares about is finding
+	 * out when that arbitrary LSN is eventually reported as written, flushed
+	 * and applied, so that it can measure the elapsed time.
+	 */
+	LagTrackerWrite(SendRqstPtr, GetCurrentTimestamp());
+
+	/*
 	 * If this is a historic timeline and we've reached the point where we
 	 * forked to the next timeline, stop streaming.
 	 *
@@ -2396,6 +2487,10 @@ XLogSendLogical(void)
 
 	if (record != NULL)
 	{
+		/* See explanation in XLogSendPhysical. */
+		LagTrackerWrite(logical_decoding_ctx->reader->EndRecPtr,
+						GetCurrentTimestamp());
+
 		LogicalDecodingProcessRecord(logical_decoding_ctx, logical_decoding_ctx->reader);
 
 		sentPtr = logical_decoding_ctx->reader->EndRecPtr;
@@ -2692,6 +2787,17 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+offset_to_interval(TimeOffset offset)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+	result->time = offset;
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2700,7 +2806,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2748,6 +2854,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		TimeOffset	writeLag;
+		TimeOffset	flushLag;
+		TimeOffset	applyLag;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2762,6 +2871,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLag = walsnd->writeLag;
+		flushLag = walsnd->flushLag;
+		applyLag = walsnd->applyLag;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2803,7 +2915,22 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			if (writeLag < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(offset_to_interval(writeLag));
+
+			if (flushLag < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(offset_to_interval(flushLag));
+
+			if (applyLag < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(offset_to_interval(applyLag));
+
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2817,12 +2944,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
@@ -2890,3 +3017,139 @@ WalSndKeepaliveIfNecessary(TimestampTz now)
 			WalSndShutdown();
 	}
 }
+
+/*
+ * Record the end of the WAL and the time it was flushed locally, so that
+ * LagTrackerRead can compute the elapsed time (lag) when this WAL position is
+ * eventually reported to have been written, flushed and applied by the
+ * standby in a reply message.
+ */
+static void
+LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time)
+{
+	bool buffer_full;
+	int new_write_head;
+	int i;
+
+	/*
+	 * If the lsn hasn't advanced since last time, then do nothing.  This way
+	 * we only record a new sample when new WAL has been written.
+	 */
+	if (LagTracker.last_lsn == lsn)
+		return;
+	LagTracker.last_lsn = lsn;
+
+	/*
+	 * If advancing the write head of the circular buffer would crash into any
+	 * of the read heads, then the buffer is full.  In other words, the
+	 * slowest reader (presumably apply) is the one that controls the release
+	 * of space.
+	 */
+	new_write_head = (LagTracker.write_head + 1) % LAG_TRACKER_BUFFER_SIZE;
+	buffer_full = false;
+	for (i = 0; i < NUM_SYNC_REP_WAIT_MODE; ++i)
+	{
+		if (new_write_head == LagTracker.read_heads[i])
+			buffer_full = true;
+	}
+
+	/*
+	 * If the buffer is full, for now we just rewind by one slot and overwrite
+	 * the last sample, as a simple (if somewhat uneven) way to lower the
+	 * sampling rate.  There may be better adaptive compaction algorithms.
+	 */
+	if (buffer_full)
+	{
+		new_write_head = LagTracker.write_head;
+		if (LagTracker.write_head > 0)
+			LagTracker.write_head--;
+		else
+			LagTracker.write_head = LAG_TRACKER_BUFFER_SIZE - 1;
+	}
+
+	/* Store a sample at the current write head position. */
+	LagTracker.buffer[LagTracker.write_head].lsn = lsn;
+	LagTracker.buffer[LagTracker.write_head].time = local_flush_time;
+	LagTracker.write_head = new_write_head;
+}
+
+/*
+ * Find out how much time has elapsed between the moment WAL position 'lsn'
+ * (or the highest known earlier LSN) was flushed locally and the time 'now'.
+ * We have a separate read head for each of the reported LSN locations we
+ * receive in replies from standby; 'head' controls which read head is
+ * used.  Whenever a read head crosses an LSN which was written into the
+ * lag buffer with LagTrackerWrite, we can use the associated timestamp to
+ * find out the time this LSN (or an earlier one) was flushed locally, and
+ * therefore compute the lag.
+ *
+ * Return -1 if no new sample data is available, and otherwise the elapsed
+ * time in microseconds.
+ */
+static TimeOffset
+LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now)
+{
+	TimestampTz time = 0;
+
+	/* Read all unread samples up to this LSN or end of buffer. */
+	while (LagTracker.read_heads[head] != LagTracker.write_head &&
+		   LagTracker.buffer[LagTracker.read_heads[head]].lsn <= lsn)
+	{
+		time = LagTracker.buffer[LagTracker.read_heads[head]].time;
+		LagTracker.last_read[head] =
+			LagTracker.buffer[LagTracker.read_heads[head]];
+		LagTracker.read_heads[head] =
+			(LagTracker.read_heads[head] + 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	if (time > now)
+	{
+		/* If the clock somehow went backwards, treat as not found. */
+		return -1;
+	}
+	else if (time == 0)
+	{
+		/*
+		 * We didn't cross a time.  If there is a future sample that we
+		 * haven't reached yet, and we've already reached at least one sample,
+		 * let's interpolate the local flushed time.  This is mainly useful for
+		 * reporting a completely stuck apply position as having increasing
+		 * lag, since otherwise we'd have to wait for it to eventually start
+		 * moving again and cross one of our samples before we can show the
+		 * lag increasing.
+		 */
+		if (LagTracker.read_heads[head] != LagTracker.write_head &&
+			LagTracker.last_read[head].time != 0)
+		{
+			double fraction;
+			WalTimeSample prev = LagTracker.last_read[head];
+			WalTimeSample next = LagTracker.buffer[LagTracker.read_heads[head]];
+
+			Assert(lsn >= prev.lsn);
+			Assert(prev.lsn < next.lsn);
+
+			if (prev.time > next.time)
+			{
+				/* If the clock somehow went backwards, treat as not found. */
+				return -1;
+			}
+
+			/* See how far we are between the previous and next samples. */
+			fraction =
+				(double) (lsn - prev.lsn) / (double) (next.lsn - prev.lsn);
+
+			/* Scale the local flush time proportionally. */
+			time = (TimestampTz)
+				((double) prev.time + (next.time - prev.time) * fraction);
+		}
+		else
+		{
+			/* Couldn't interpolate due to lack of data. */
+			return -1;
+		}
+	}
+
+	/* Return the elapsed time since local flush time in microseconds. */
+	Assert(time != 0);
+	return now - time;
+}
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index ec4aedb..af5b50d 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2772,7 +2772,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 5e6ccfc..2c59056 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -47,6 +47,11 @@ typedef struct WalSnd
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
 
+	/* Measured lag times, or -1 for unknown/none. */
+	TimeOffset	writeLag;
+	TimeOffset	flushLag;
+	TimeOffset	applyLag;
+
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
 
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index bd13ae6..55b5ca7 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1831,10 +1831,13 @@ pg_stat_replication| SELECT s.pid,
     w.write_location,
     w.flush_location,
     w.replay_location,
+    w.write_lag,
+    w.flush_lag,
+    w.replay_lag,
     w.sync_priority,
     w.sync_state
    FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn)
-     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) ON ((s.pid = w.pid)))
+     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, write_lag, flush_lag, replay_lag, sync_priority, sync_state) ON ((s.pid = w.pid)))
      LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
 pg_stat_ssl| SELECT s.pid,
     s.ssl,

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index dcb2d33..d425037 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1696,6 +1696,36 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written it (but not yet
+      flushed it or applied it).  This can be used to gauge the delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_write</literal> incurred while committing if this
+      server was configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written and flushed it
+      (but not yet applied it).  This can be used to gauge the delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_flush</literal> incurred while committing if this
+      server was configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written, flushed and
+      applied it.  This can be used to gauge the delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_apply</literal> incurred while committing if this
+      server was configured as a synchronous standby.</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
@@ -1745,6 +1775,38 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
    listed; no information is available about downstream standby servers.
   </para>
 
+  <para>
+   The 'lag' times reported in the <structname>pg_stat_replication</structname>
+   view are measurements of the time taken for recent WAL to be written,
+   flushed and replayed and for the sender to know about it.  These times
+   represent the commit delay that was (or would have been) introduced by each
+   synchronous commit level, if the remote server was configured as a
+   synchronous standby.  For an asynchronous standby, the
+   <structfield>replay_lag</structfield> column approximates the delay
+   before recent transactions became visible to queries.  If the standby
+   server has entirely caught up with the sending server and there is no more
+   WAL activity, the most recently measured lag times will continue to be
+   displayed for a short time and then show NULL.
+  </para>
+
+  <note>
+   <para>
+    The reported lag times are not predictions of how long it will take for
+    the standby to catch up with the sending server assuming the current
+    rate of replay.  Such a system would show similar times while new WAL is
+    being generated, but would differ when the sender becomes idle.  In
+    particular, when the standby has caught up completely, 
+    <structname>pg_stat_replication</structname> shows the time taken to
+    write, flush and replay the most recent reported WAL position rather than
+    zero as some users might expect.  This is consistent with the goal of
+    measuring synchronous commit and transaction visibility delays for
+    recent write transactions.
+    To reduce confusion for users expecting a different model of lag, the
+    lag columns revert to NULL after a short time on a fully replayed idle
+    system.
+   </para>
+  </note>
+
   <table id="pg-stat-wal-receiver-view" xreflabel="pg_stat_wal_receiver">
    <title><structname>pg_stat_wal_receiver</structname> View</title>
    <tgroup cols="3">
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 9480377..92b2972 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -11554,6 +11554,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 {
 	static TimestampTz last_fail_time = 0;
 	TimestampTz now;
+	bool		streaming_reply_sent = false;
 
 	/*-------
 	 * Standby mode is implemented by a state machine:
@@ -11877,6 +11878,19 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 					}
 
 					/*
+					 * Since we have replayed everything we have received so
+					 * far and are about to start waiting for more WAL, let's
+					 * tell the upstream server our replay location now so
+					 * that pg_stat_replication doesn't show stale
+					 * information.
+					 */
+					if (!streaming_reply_sent)
+					{
+						WalRcvForceReply();
+						streaming_reply_sent = true;
+					}
+
+					/*
 					 * Wait for more WAL to arrive. Time out after 5 seconds
 					 * to react to a trigger file promptly.
 					 */
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index b6552da..c109ae8 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -705,6 +705,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 7561770..e7f19bc 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -190,6 +190,26 @@ static volatile sig_atomic_t replication_active = false;
 static LogicalDecodingContext *logical_decoding_ctx = NULL;
 static XLogRecPtr logical_startptr = InvalidXLogRecPtr;
 
+/* A sample associating a log position with the time it was written. */
+typedef struct
+{
+	XLogRecPtr lsn;
+	TimestampTz time;
+} WalTimeSample;
+
+/* The size of our buffer of time samples. */
+#define LAG_TRACKER_BUFFER_SIZE 8192
+
+/* A mechanism for tracking replication lag. */
+static struct
+{
+	XLogRecPtr last_lsn;
+	WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE];
+	int write_head;
+	int read_heads[NUM_SYNC_REP_WAIT_MODE];
+	WalTimeSample last_read[NUM_SYNC_REP_WAIT_MODE];
+} LagTracker;
+
 /* Signal handlers */
 static void WalSndSigHupHandler(SIGNAL_ARGS);
 static void WalSndXLogSendHandler(SIGNAL_ARGS);
@@ -221,6 +241,8 @@ static long WalSndComputeSleeptime(TimestampTz now);
 static void WalSndPrepareWrite(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static void WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+static void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+static TimeOffset LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
 
 static void XLogRead(char *buf, XLogRecPtr startptr, Size count);
 
@@ -246,6 +268,9 @@ InitWalSender(void)
 	 */
 	MarkPostmasterChildWalSender();
 	SendPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE);
+
+	/* Initialize empty timestamp buffer for lag tracking. */
+	memset(&LagTracker, 0, sizeof(LagTracker));
 }
 
 /*
@@ -1556,6 +1581,13 @@ ProcessStandbyReplyMessage(void)
 				flushPtr,
 				applyPtr;
 	bool		replyRequested;
+	TimeOffset	writeLag,
+				flushLag,
+				applyLag;
+	bool		clearLagTimes;
+	TimestampTz now;
+
+	static bool	fullyAppliedLastTime = false;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
@@ -1570,6 +1602,30 @@ ProcessStandbyReplyMessage(void)
 		 (uint32) (applyPtr >> 32), (uint32) applyPtr,
 		 replyRequested ? " (reply requested)" : "");
 
+	/* See if we can compute the round-trip lag for these positions. */
+	now = GetCurrentTimestamp();
+	writeLag = LagTrackerRead(SYNC_REP_WAIT_WRITE, writePtr, now);
+	flushLag = LagTrackerRead(SYNC_REP_WAIT_FLUSH, flushPtr, now);
+	applyLag = LagTrackerRead(SYNC_REP_WAIT_APPLY, applyPtr, now);
+
+	/*
+	 * If the standby reports that it has fully replayed the WAL in two
+	 * consecutive reply messages, then the second such message must result
+	 * from wal_receiver_status_interval expiring on the standby.  This is a
+	 * convenient time to forget the lag times measured when it last
+	 * wrote/flushed/applied a WAL record, to avoid displaying stale lag data
+	 * until more WAL traffic arrives.
+	 */
+	clearLagTimes = false;
+	if (applyPtr == sentPtr)
+	{
+		if (fullyAppliedLastTime)
+			clearLagTimes = true;
+		fullyAppliedLastTime = true;
+	}
+	else
+		fullyAppliedLastTime = false;
+
 	/* Send a reply if the standby requested one. */
 	if (replyRequested)
 		WalSndKeepalive(false);
@@ -1585,6 +1641,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLag != -1 || clearLagTimes)
+			walsnd->writeLag = writeLag;
+		if (flushLag != -1 || clearLagTimes)
+			walsnd->flushLag = flushLag;
+		if (applyLag != -1 || clearLagTimes)
+			walsnd->applyLag = applyLag;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1973,6 +2035,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLag = -1;
+			walsnd->flushLag = -1;
+			walsnd->applyLag = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2300,6 +2365,32 @@ XLogSendPhysical(void)
 	}
 
 	/*
+	 * Record the current system time as an approximation of the time at which
+	 * this WAL position was written for the purposes of lag tracking.
+	 *
+	 * In theory we could make XLogFlush() record a time in shmem whenever WAL
+	 * is flushed and we could get that time as well as the LSN when we call
+	 * GetFlushRecPtr() above (and likewise for the cascading standby
+	 * equivalent), but rather than putting any new code into the hot WAL path
+	 * it seems good enough to capture the time here.  We should reach this
+	 * after XLogFlush() runs WalSndWakeupProcessRequests(), and although that
+	 * may take some time, we read the WAL flush pointer and take the time
+	 * very close to together here so that we'll get a later position if it
+	 * is still moving.
+	 *
+	 * Because LagTrackerWriter ignores samples when the LSN hasn't advanced,
+	 * this gives us a cheap approximation for the WAL flush time for this
+	 * LSN.
+	 *
+	 * Note that the LSN is not necessarily the LSN for the data contained in
+	 * the present message; it's the end of the the WAL, which might be
+	 * further ahead.  All the lag tracking machinery cares about is finding
+	 * out when that arbitrary LSN is eventually reported as written, flushed
+	 * and applied, so that it can measure the elapsed time.
+	 */
+	LagTrackerWrite(SendRqstPtr, GetCurrentTimestamp());
+
+	/*
 	 * If this is a historic timeline and we've reached the point where we
 	 * forked to the next timeline, stop streaming.
 	 *
@@ -2453,6 +2544,10 @@ XLogSendLogical(void)
 
 	if (record != NULL)
 	{
+		/* See explanation in XLogSendPhysical. */
+		LagTrackerWrite(logical_decoding_ctx->reader->EndRecPtr,
+						GetCurrentTimestamp());
+
 		LogicalDecodingProcessRecord(logical_decoding_ctx, logical_decoding_ctx->reader);
 
 		sentPtr = logical_decoding_ctx->reader->EndRecPtr;
@@ -2749,6 +2844,17 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+offset_to_interval(TimeOffset offset)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+	result->time = offset;
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2757,7 +2863,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2805,6 +2911,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		TimeOffset	writeLag;
+		TimeOffset	flushLag;
+		TimeOffset	applyLag;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2819,6 +2928,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLag = walsnd->writeLag;
+		flushLag = walsnd->flushLag;
+		applyLag = walsnd->applyLag;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2860,7 +2972,22 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			if (writeLag < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(offset_to_interval(writeLag));
+
+			if (flushLag < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(offset_to_interval(flushLag));
+
+			if (applyLag < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(offset_to_interval(applyLag));
+
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2874,12 +3001,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
@@ -2947,3 +3074,139 @@ WalSndKeepaliveIfNecessary(TimestampTz now)
 			WalSndShutdown();
 	}
 }
+
+/*
+ * Record the end of the WAL and the time it was flushed locally, so that
+ * LagTrackerRead can compute the elapsed time (lag) when this WAL position is
+ * eventually reported to have been written, flushed and applied by the
+ * standby in a reply message.
+ */
+static void
+LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time)
+{
+	bool buffer_full;
+	int new_write_head;
+	int i;
+
+	/*
+	 * If the lsn hasn't advanced since last time, then do nothing.  This way
+	 * we only record a new sample when new WAL has been written.
+	 */
+	if (LagTracker.last_lsn == lsn)
+		return;
+	LagTracker.last_lsn = lsn;
+
+	/*
+	 * If advancing the write head of the circular buffer would crash into any
+	 * of the read heads, then the buffer is full.  In other words, the
+	 * slowest reader (presumably apply) is the one that controls the release
+	 * of space.
+	 */
+	new_write_head = (LagTracker.write_head + 1) % LAG_TRACKER_BUFFER_SIZE;
+	buffer_full = false;
+	for (i = 0; i < NUM_SYNC_REP_WAIT_MODE; ++i)
+	{
+		if (new_write_head == LagTracker.read_heads[i])
+			buffer_full = true;
+	}
+
+	/*
+	 * If the buffer is full, for now we just rewind by one slot and overwrite
+	 * the last sample, as a simple (if somewhat uneven) way to lower the
+	 * sampling rate.  There may be better adaptive compaction algorithms.
+	 */
+	if (buffer_full)
+	{
+		new_write_head = LagTracker.write_head;
+		if (LagTracker.write_head > 0)
+			LagTracker.write_head--;
+		else
+			LagTracker.write_head = LAG_TRACKER_BUFFER_SIZE - 1;
+	}
+
+	/* Store a sample at the current write head position. */
+	LagTracker.buffer[LagTracker.write_head].lsn = lsn;
+	LagTracker.buffer[LagTracker.write_head].time = local_flush_time;
+	LagTracker.write_head = new_write_head;
+}
+
+/*
+ * Find out how much time has elapsed between the moment WAL position 'lsn'
+ * (or the highest known earlier LSN) was flushed locally and the time 'now'.
+ * We have a separate read head for each of the reported LSN locations we
+ * receive in replies from standby; 'head' controls which read head is
+ * used.  Whenever a read head crosses an LSN which was written into the
+ * lag buffer with LagTrackerWrite, we can use the associated timestamp to
+ * find out the time this LSN (or an earlier one) was flushed locally, and
+ * therefore compute the lag.
+ *
+ * Return -1 if no new sample data is available, and otherwise the elapsed
+ * time in microseconds.
+ */
+static TimeOffset
+LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now)
+{
+	TimestampTz time = 0;
+
+	/* Read all unread samples up to this LSN or end of buffer. */
+	while (LagTracker.read_heads[head] != LagTracker.write_head &&
+		   LagTracker.buffer[LagTracker.read_heads[head]].lsn <= lsn)
+	{
+		time = LagTracker.buffer[LagTracker.read_heads[head]].time;
+		LagTracker.last_read[head] =
+			LagTracker.buffer[LagTracker.read_heads[head]];
+		LagTracker.read_heads[head] =
+			(LagTracker.read_heads[head] + 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	if (time > now)
+	{
+		/* If the clock somehow went backwards, treat as not found. */
+		return -1;
+	}
+	else if (time == 0)
+	{
+		/*
+		 * We didn't cross a time.  If there is a future sample that we
+		 * haven't reached yet, and we've already reached at least one sample,
+		 * let's interpolate the local flushed time.  This is mainly useful for
+		 * reporting a completely stuck apply position as having increasing
+		 * lag, since otherwise we'd have to wait for it to eventually start
+		 * moving again and cross one of our samples before we can show the
+		 * lag increasing.
+		 */
+		if (LagTracker.read_heads[head] != LagTracker.write_head &&
+			LagTracker.last_read[head].time != 0)
+		{
+			double fraction;
+			WalTimeSample prev = LagTracker.last_read[head];
+			WalTimeSample next = LagTracker.buffer[LagTracker.read_heads[head]];
+
+			Assert(lsn >= prev.lsn);
+			Assert(prev.lsn < next.lsn);
+
+			if (prev.time > next.time)
+			{
+				/* If the clock somehow went backwards, treat as not found. */
+				return -1;
+			}
+
+			/* See how far we are between the previous and next samples. */
+			fraction =
+				(double) (lsn - prev.lsn) / (double) (next.lsn - prev.lsn);
+
+			/* Scale the local flush time proportionally. */
+			time = (TimestampTz)
+				((double) prev.time + (next.time - prev.time) * fraction);
+		}
+		else
+		{
+			/* Couldn't interpolate due to lack of data. */
+			return -1;
+		}
+	}
+
+	/* Return the elapsed time since local flush time in microseconds. */
+	Assert(time != 0);
+	return now - time;
+}
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index 836d6ff..2b9a3c6 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2801,7 +2801,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 5e6ccfc..2c59056 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -47,6 +47,11 @@ typedef struct WalSnd
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
 
+	/* Measured lag times, or -1 for unknown/none. */
+	TimeOffset	writeLag;
+	TimeOffset	flushLag;
+	TimeOffset	applyLag;
+
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
 
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index bd13ae6..55b5ca7 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1831,10 +1831,13 @@ pg_stat_replication| SELECT s.pid,
     w.write_location,
     w.flush_location,
     w.replay_location,
+    w.write_lag,
+    w.flush_lag,
+    w.replay_lag,
     w.sync_priority,
     w.sync_state
    FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn)
-     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) ON ((s.pid = w.pid)))
+     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, write_lag, flush_lag, replay_lag, sync_priority, sync_state) ON ((s.pid = w.pid)))
      LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
 pg_stat_ssl| SELECT s.pid,
     s.ssl,

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index dcb2d33..eda14cf 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -1696,6 +1696,36 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
       standby server</entry>
     </row>
     <row>
+     <entry><structfield>write_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written it (but not yet
+      flushed it or applied it).  This can be used to gauge the delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_write</literal> incurred while committing if this
+      server was configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>flush_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written and flushed it
+      (but not yet applied it).  This can be used to gauge the delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_flush</literal> incurred while committing if this
+      server was configured as a synchronous standby.</entry>
+    </row>
+    <row>
+     <entry><structfield>replay_lag</></entry>
+     <entry><type>interval</></entry>
+     <entry>Time elapsed between flushing recent WAL locally and receiving
+      notification that this standby server has written, flushed and
+      applied it.  This can be used to gauge the delay that
+      <literal>synchronous_commit</literal> level
+      <literal>remote_apply</literal> incurred while committing if this
+      server was configured as a synchronous standby.</entry>
+    </row>
+    <row>
      <entry><structfield>sync_priority</></entry>
      <entry><type>integer</></entry>
      <entry>Priority of this standby server for being chosen as the
@@ -1745,6 +1775,45 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i
    listed; no information is available about downstream standby servers.
   </para>
 
+  <para>
+   The lag times reported in the <structname>pg_stat_replication</structname>
+   view are measurements of the time taken for recent WAL to be written,
+   flushed and replayed and for the sender to know about it.  These times
+   represent the commit delay that was (or would have been) introduced by each
+   synchronous commit level, if the remote server was configured as a
+   synchronous standby.  For an asynchronous standby, the
+   <structfield>replay_lag</structfield> column approximates the delay
+   before recent transactions became visible to queries.  If the standby
+   server has entirely caught up with the sending server and there is no more
+   WAL activity, the most recently measured lag times will continue to be
+   displayed for a short time and then show NULL.
+  </para>
+
+  <para>
+   Lag times work automatically for physical replication. Logical decoding
+   plugins may optionally emit tracking messages; if they do not, the tracking
+   mechanism will simply display NULL lag.
+  </para>
+
+  <note>
+   <para>
+    The reported lag times are not predictions of how long it will take for
+    the standby to catch up with the sending server assuming the current
+    rate of replay.  Such a system would show similar times while new WAL is
+    being generated, but would differ when the sender becomes idle.  In
+    particular, when the standby has caught up completely, 
+    <structname>pg_stat_replication</structname> shows the time taken to
+    write, flush and replay the most recent reported WAL position rather than
+    zero as some users might expect.  This is consistent with the goal of
+    measuring synchronous commit and transaction visibility delays for
+    recent write transactions.
+    To reduce confusion for users expecting a different model of lag, the
+    lag columns revert to NULL after a short time on a fully replayed idle
+    system. Monitoring systems should choose whether the represent this
+    as missing data, zero or continue to display the last known value.
+   </para>
+  </note>
+
   <table id="pg-stat-wal-receiver-view" xreflabel="pg_stat_wal_receiver">
    <title><structname>pg_stat_wal_receiver</structname> View</title>
    <tgroup cols="3">
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index ff4cf3a..eca3c04 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -11554,6 +11554,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 {
 	static TimestampTz last_fail_time = 0;
 	TimestampTz now;
+	bool		streaming_reply_sent = false;
 
 	/*-------
 	 * Standby mode is implemented by a state machine:
@@ -11877,6 +11878,19 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
 					}
 
 					/*
+					 * Since we have replayed everything we have received so
+					 * far and are about to start waiting for more WAL, let's
+					 * tell the upstream server our replay location now so
+					 * that pg_stat_replication doesn't show stale
+					 * information.
+					 */
+					if (!streaming_reply_sent)
+					{
+						WalRcvForceReply();
+						streaming_reply_sent = true;
+					}
+
+					/*
 					 * Wait for more WAL to arrive. Time out after 5 seconds
 					 * to react to a trigger file promptly.
 					 */
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index b6552da..c109ae8 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -705,6 +705,9 @@ CREATE VIEW pg_stat_replication AS
             W.write_location,
             W.flush_location,
             W.replay_location,
+            W.write_lag,
+            W.flush_lag,
+            W.replay_lag,
             W.sync_priority,
             W.sync_state
     FROM pg_stat_get_activity(NULL) AS S
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 7561770..29d1319 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -190,6 +190,26 @@ static volatile sig_atomic_t replication_active = false;
 static LogicalDecodingContext *logical_decoding_ctx = NULL;
 static XLogRecPtr logical_startptr = InvalidXLogRecPtr;
 
+/* A sample associating a log position with the time it was written. */
+typedef struct
+{
+	XLogRecPtr lsn;
+	TimestampTz time;
+} WalTimeSample;
+
+/* The size of our buffer of time samples. */
+#define LAG_TRACKER_BUFFER_SIZE 8192
+
+/* A mechanism for tracking replication lag. */
+static struct
+{
+	XLogRecPtr last_lsn;
+	WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE];
+	int write_head;
+	int read_heads[NUM_SYNC_REP_WAIT_MODE];
+	WalTimeSample last_read[NUM_SYNC_REP_WAIT_MODE];
+} LagTracker;
+
 /* Signal handlers */
 static void WalSndSigHupHandler(SIGNAL_ARGS);
 static void WalSndXLogSendHandler(SIGNAL_ARGS);
@@ -221,6 +241,7 @@ static long WalSndComputeSleeptime(TimestampTz now);
 static void WalSndPrepareWrite(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static void WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, bool last_write);
 static XLogRecPtr WalSndWaitForWal(XLogRecPtr loc);
+static TimeOffset LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now);
 
 static void XLogRead(char *buf, XLogRecPtr startptr, Size count);
 
@@ -246,6 +267,9 @@ InitWalSender(void)
 	 */
 	MarkPostmasterChildWalSender();
 	SendPostmasterSignal(PMSIGNAL_ADVANCE_STATE_MACHINE);
+
+	/* Initialize empty timestamp buffer for lag tracking. */
+	memset(&LagTracker, 0, sizeof(LagTracker));
 }
 
 /*
@@ -1556,6 +1580,13 @@ ProcessStandbyReplyMessage(void)
 				flushPtr,
 				applyPtr;
 	bool		replyRequested;
+	TimeOffset	writeLag,
+				flushLag,
+				applyLag;
+	bool		clearLagTimes;
+	TimestampTz now;
+
+	static bool	fullyAppliedLastTime = false;
 
 	/* the caller already consumed the msgtype byte */
 	writePtr = pq_getmsgint64(&reply_message);
@@ -1570,6 +1601,30 @@ ProcessStandbyReplyMessage(void)
 		 (uint32) (applyPtr >> 32), (uint32) applyPtr,
 		 replyRequested ? " (reply requested)" : "");
 
+	/* See if we can compute the round-trip lag for these positions. */
+	now = GetCurrentTimestamp();
+	writeLag = LagTrackerRead(SYNC_REP_WAIT_WRITE, writePtr, now);
+	flushLag = LagTrackerRead(SYNC_REP_WAIT_FLUSH, flushPtr, now);
+	applyLag = LagTrackerRead(SYNC_REP_WAIT_APPLY, applyPtr, now);
+
+	/*
+	 * If the standby reports that it has fully replayed the WAL in two
+	 * consecutive reply messages, then the second such message must result
+	 * from wal_receiver_status_interval expiring on the standby.  This is a
+	 * convenient time to forget the lag times measured when it last
+	 * wrote/flushed/applied a WAL record, to avoid displaying stale lag data
+	 * until more WAL traffic arrives.
+	 */
+	clearLagTimes = false;
+	if (applyPtr == sentPtr)
+	{
+		if (fullyAppliedLastTime)
+			clearLagTimes = true;
+		fullyAppliedLastTime = true;
+	}
+	else
+		fullyAppliedLastTime = false;
+
 	/* Send a reply if the standby requested one. */
 	if (replyRequested)
 		WalSndKeepalive(false);
@@ -1585,6 +1640,12 @@ ProcessStandbyReplyMessage(void)
 		walsnd->write = writePtr;
 		walsnd->flush = flushPtr;
 		walsnd->apply = applyPtr;
+		if (writeLag != -1 || clearLagTimes)
+			walsnd->writeLag = writeLag;
+		if (flushLag != -1 || clearLagTimes)
+			walsnd->flushLag = flushLag;
+		if (applyLag != -1 || clearLagTimes)
+			walsnd->applyLag = applyLag;
 		SpinLockRelease(&walsnd->mutex);
 	}
 
@@ -1973,6 +2034,9 @@ InitWalSenderSlot(void)
 			walsnd->write = InvalidXLogRecPtr;
 			walsnd->flush = InvalidXLogRecPtr;
 			walsnd->apply = InvalidXLogRecPtr;
+			walsnd->writeLag = -1;
+			walsnd->flushLag = -1;
+			walsnd->applyLag = -1;
 			walsnd->state = WALSNDSTATE_STARTUP;
 			walsnd->latch = &MyProc->procLatch;
 			SpinLockRelease(&walsnd->mutex);
@@ -2300,6 +2364,32 @@ XLogSendPhysical(void)
 	}
 
 	/*
+	 * Record the current system time as an approximation of the time at which
+	 * this WAL position was written for the purposes of lag tracking.
+	 *
+	 * In theory we could make XLogFlush() record a time in shmem whenever WAL
+	 * is flushed and we could get that time as well as the LSN when we call
+	 * GetFlushRecPtr() above (and likewise for the cascading standby
+	 * equivalent), but rather than putting any new code into the hot WAL path
+	 * it seems good enough to capture the time here.  We should reach this
+	 * after XLogFlush() runs WalSndWakeupProcessRequests(), and although that
+	 * may take some time, we read the WAL flush pointer and take the time
+	 * very close to together here so that we'll get a later position if it
+	 * is still moving.
+	 *
+	 * Because LagTrackerWriter ignores samples when the LSN hasn't advanced,
+	 * this gives us a cheap approximation for the WAL flush time for this
+	 * LSN.
+	 *
+	 * Note that the LSN is not necessarily the LSN for the data contained in
+	 * the present message; it's the end of the the WAL, which might be
+	 * further ahead.  All the lag tracking machinery cares about is finding
+	 * out when that arbitrary LSN is eventually reported as written, flushed
+	 * and applied, so that it can measure the elapsed time.
+	 */
+	LagTrackerWrite(SendRqstPtr, GetCurrentTimestamp());
+
+	/*
 	 * If this is a historic timeline and we've reached the point where we
 	 * forked to the next timeline, stop streaming.
 	 *
@@ -2453,6 +2543,11 @@ XLogSendLogical(void)
 
 	if (record != NULL)
 	{
+		/*
+		 * Note the lack of any call to LagTrackerWrite() which is the responsibility
+		 * of the logical decoding plugin. Response messages are handled normally,
+		 * so this responsibility does not extend to needing to call LagTrackerRead().
+		 */
 		LogicalDecodingProcessRecord(logical_decoding_ctx, logical_decoding_ctx->reader);
 
 		sentPtr = logical_decoding_ctx->reader->EndRecPtr;
@@ -2749,6 +2844,17 @@ WalSndGetStateString(WalSndState state)
 	return "UNKNOWN";
 }
 
+static Interval *
+offset_to_interval(TimeOffset offset)
+{
+	Interval *result = palloc(sizeof(Interval));
+
+	result->month = 0;
+	result->day = 0;
+	result->time = offset;
+
+	return result;
+}
 
 /*
  * Returns activity of walsenders, including pids and xlog locations sent to
@@ -2757,7 +2863,7 @@ WalSndGetStateString(WalSndState state)
 Datum
 pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 {
-#define PG_STAT_GET_WAL_SENDERS_COLS	8
+#define PG_STAT_GET_WAL_SENDERS_COLS	11
 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 	TupleDesc	tupdesc;
 	Tuplestorestate *tupstore;
@@ -2805,6 +2911,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		XLogRecPtr	write;
 		XLogRecPtr	flush;
 		XLogRecPtr	apply;
+		TimeOffset	writeLag;
+		TimeOffset	flushLag;
+		TimeOffset	applyLag;
 		int			priority;
 		WalSndState state;
 		Datum		values[PG_STAT_GET_WAL_SENDERS_COLS];
@@ -2819,6 +2928,9 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 		write = walsnd->write;
 		flush = walsnd->flush;
 		apply = walsnd->apply;
+		writeLag = walsnd->writeLag;
+		flushLag = walsnd->flushLag;
+		applyLag = walsnd->applyLag;
 		priority = walsnd->sync_standby_priority;
 		SpinLockRelease(&walsnd->mutex);
 
@@ -2860,7 +2972,22 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 */
 			priority = XLogRecPtrIsInvalid(walsnd->flush) ? 0 : priority;
 
-			values[6] = Int32GetDatum(priority);
+			if (writeLag < 0)
+				nulls[6] = true;
+			else
+				values[6] = IntervalPGetDatum(offset_to_interval(writeLag));
+
+			if (flushLag < 0)
+				nulls[7] = true;
+			else
+				values[7] = IntervalPGetDatum(offset_to_interval(flushLag));
+
+			if (applyLag < 0)
+				nulls[8] = true;
+			else
+				values[8] = IntervalPGetDatum(offset_to_interval(applyLag));
+
+			values[9] = Int32GetDatum(priority);
 
 			/*
 			 * More easily understood version of standby state. This is purely
@@ -2874,12 +3001,12 @@ pg_stat_get_wal_senders(PG_FUNCTION_ARGS)
 			 * states. We report just "quorum" for them.
 			 */
 			if (priority == 0)
-				values[7] = CStringGetTextDatum("async");
+				values[10] = CStringGetTextDatum("async");
 			else if (list_member_int(sync_standbys, i))
-				values[7] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
+				values[10] = SyncRepConfig->syncrep_method == SYNC_REP_PRIORITY ?
 					CStringGetTextDatum("sync") : CStringGetTextDatum("quorum");
 			else
-				values[7] = CStringGetTextDatum("potential");
+				values[10] = CStringGetTextDatum("potential");
 		}
 
 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
@@ -2947,3 +3074,143 @@ WalSndKeepaliveIfNecessary(TimestampTz now)
 			WalSndShutdown();
 	}
 }
+
+/*
+ * Record the end of the WAL and the time it was flushed locally, so that
+ * LagTrackerRead can compute the elapsed time (lag) when this WAL position is
+ * eventually reported to have been written, flushed and applied by the
+ * standby in a reply message.
+ * Exported to allow logical decoding plugins to call this when they choose.
+ */
+void
+LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time)
+{
+	bool buffer_full;
+	int new_write_head;
+	int i;
+
+	if (!am_walsender)
+		return;
+
+	/*
+	 * If the lsn hasn't advanced since last time, then do nothing.  This way
+	 * we only record a new sample when new WAL has been written.
+	 */
+	if (LagTracker.last_lsn == lsn)
+		return;
+	LagTracker.last_lsn = lsn;
+
+	/*
+	 * If advancing the write head of the circular buffer would crash into any
+	 * of the read heads, then the buffer is full.  In other words, the
+	 * slowest reader (presumably apply) is the one that controls the release
+	 * of space.
+	 */
+	new_write_head = (LagTracker.write_head + 1) % LAG_TRACKER_BUFFER_SIZE;
+	buffer_full = false;
+	for (i = 0; i < NUM_SYNC_REP_WAIT_MODE; ++i)
+	{
+		if (new_write_head == LagTracker.read_heads[i])
+			buffer_full = true;
+	}
+
+	/*
+	 * If the buffer is full, for now we just rewind by one slot and overwrite
+	 * the last sample, as a simple (if somewhat uneven) way to lower the
+	 * sampling rate.  There may be better adaptive compaction algorithms.
+	 */
+	if (buffer_full)
+	{
+		new_write_head = LagTracker.write_head;
+		if (LagTracker.write_head > 0)
+			LagTracker.write_head--;
+		else
+			LagTracker.write_head = LAG_TRACKER_BUFFER_SIZE - 1;
+	}
+
+	/* Store a sample at the current write head position. */
+	LagTracker.buffer[LagTracker.write_head].lsn = lsn;
+	LagTracker.buffer[LagTracker.write_head].time = local_flush_time;
+	LagTracker.write_head = new_write_head;
+}
+
+/*
+ * Find out how much time has elapsed between the moment WAL position 'lsn'
+ * (or the highest known earlier LSN) was flushed locally and the time 'now'.
+ * We have a separate read head for each of the reported LSN locations we
+ * receive in replies from standby; 'head' controls which read head is
+ * used.  Whenever a read head crosses an LSN which was written into the
+ * lag buffer with LagTrackerWrite, we can use the associated timestamp to
+ * find out the time this LSN (or an earlier one) was flushed locally, and
+ * therefore compute the lag.
+ *
+ * Return -1 if no new sample data is available, and otherwise the elapsed
+ * time in microseconds.
+ */
+static TimeOffset
+LagTrackerRead(int head, XLogRecPtr lsn, TimestampTz now)
+{
+	TimestampTz time = 0;
+
+	/* Read all unread samples up to this LSN or end of buffer. */
+	while (LagTracker.read_heads[head] != LagTracker.write_head &&
+		   LagTracker.buffer[LagTracker.read_heads[head]].lsn <= lsn)
+	{
+		time = LagTracker.buffer[LagTracker.read_heads[head]].time;
+		LagTracker.last_read[head] =
+			LagTracker.buffer[LagTracker.read_heads[head]];
+		LagTracker.read_heads[head] =
+			(LagTracker.read_heads[head] + 1) % LAG_TRACKER_BUFFER_SIZE;
+	}
+
+	if (time > now)
+	{
+		/* If the clock somehow went backwards, treat as not found. */
+		return -1;
+	}
+	else if (time == 0)
+	{
+		/*
+		 * We didn't cross a time.  If there is a future sample that we
+		 * haven't reached yet, and we've already reached at least one sample,
+		 * let's interpolate the local flushed time.  This is mainly useful for
+		 * reporting a completely stuck apply position as having increasing
+		 * lag, since otherwise we'd have to wait for it to eventually start
+		 * moving again and cross one of our samples before we can show the
+		 * lag increasing.
+		 */
+		if (LagTracker.read_heads[head] != LagTracker.write_head &&
+			LagTracker.last_read[head].time != 0)
+		{
+			double fraction;
+			WalTimeSample prev = LagTracker.last_read[head];
+			WalTimeSample next = LagTracker.buffer[LagTracker.read_heads[head]];
+
+			Assert(lsn >= prev.lsn);
+			Assert(prev.lsn < next.lsn);
+
+			if (prev.time > next.time)
+			{
+				/* If the clock somehow went backwards, treat as not found. */
+				return -1;
+			}
+
+			/* See how far we are between the previous and next samples. */
+			fraction =
+				(double) (lsn - prev.lsn) / (double) (next.lsn - prev.lsn);
+
+			/* Scale the local flush time proportionally. */
+			time = (TimestampTz)
+				((double) prev.time + (next.time - prev.time) * fraction);
+		}
+		else
+		{
+			/* Couldn't interpolate due to lack of data. */
+			return -1;
+		}
+	}
+
+	/* Return the elapsed time since local flush time in microseconds. */
+	Assert(time != 0);
+	return now - time;
+}
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index 836d6ff..2b9a3c6 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -2801,7 +2801,7 @@ DATA(insert OID = 2022 (  pg_stat_get_activity			PGNSP PGUID 12 1 100 0 0 f f f
 DESCR("statistics: information about currently active backends");
 DATA(insert OID = 3318 (  pg_stat_get_progress_info			  PGNSP PGUID 12 1 100 0 0 f f f f t t s r 1 0 2249 "25" "{25,23,26,26,20,20,20,20,20,20,20,20,20,20}" "{i,o,o,o,o,o,o,o,o,o,o,o,o,o}" "{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10}" _null_ _null_ pg_stat_get_progress_info _null_ _null_ _null_ ));
 DESCR("statistics: information about progress of backends running maintenance command");
-DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,23,25}" "{o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
+DATA(insert OID = 3099 (  pg_stat_get_wal_senders	PGNSP PGUID 12 1 10 0 0 f f f f f t s r 0 0 2249 "" "{23,25,3220,3220,3220,3220,1186,1186,1186,23,25}" "{o,o,o,o,o,o,o,o,o,o,o}" "{pid,state,sent_location,write_location,flush_location,replay_location,write_lag,flush_lag,replay_lag,sync_priority,sync_state}" _null_ _null_ pg_stat_get_wal_senders _null_ _null_ _null_ ));
 DESCR("statistics: information about currently active replication");
 DATA(insert OID = 3317 (  pg_stat_get_wal_receiver	PGNSP PGUID 12 1 0 0 0 f f f f f f s r 0 0 2249 "" "{23,25,3220,23,3220,23,1184,1184,3220,1184,25,25}" "{o,o,o,o,o,o,o,o,o,o,o,o}" "{pid,status,receive_start_lsn,receive_start_tli,received_lsn,received_tli,last_msg_send_time,last_msg_receipt_time,latest_end_lsn,latest_end_time,slot_name,conninfo}" _null_ _null_ pg_stat_get_wal_receiver _null_ _null_ _null_ ));
 DESCR("statistics: information about WAL receiver");
diff --git a/src/include/replication/logical.h b/src/include/replication/logical.h
index fd34964..44da2e9 100644
--- a/src/include/replication/logical.h
+++ b/src/include/replication/logical.h
@@ -97,6 +97,8 @@ extern void LogicalIncreaseRestartDecodingForSlot(XLogRecPtr current_lsn,
 									  XLogRecPtr restart_lsn);
 extern void LogicalConfirmReceivedLocation(XLogRecPtr lsn);
 
+extern void LagTrackerWrite(XLogRecPtr lsn, TimestampTz local_flush_time);
+
 extern bool filter_by_origin_cb_wrapper(LogicalDecodingContext *ctx, RepOriginId origin_id);
 
 #endif
diff --git a/src/include/replication/walsender_private.h b/src/include/replication/walsender_private.h
index 5e6ccfc..2c59056 100644
--- a/src/include/replication/walsender_private.h
+++ b/src/include/replication/walsender_private.h
@@ -47,6 +47,11 @@ typedef struct WalSnd
 	XLogRecPtr	flush;
 	XLogRecPtr	apply;
 
+	/* Measured lag times, or -1 for unknown/none. */
+	TimeOffset	writeLag;
+	TimeOffset	flushLag;
+	TimeOffset	applyLag;
+
 	/* Protects shared variables shown above. */
 	slock_t		mutex;
 
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index bd13ae6..55b5ca7 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1831,10 +1831,13 @@ pg_stat_replication| SELECT s.pid,
     w.write_location,
     w.flush_location,
     w.replay_location,
+    w.write_lag,
+    w.flush_lag,
+    w.replay_lag,
     w.sync_priority,
     w.sync_state
    FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn)
-     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) ON ((s.pid = w.pid)))
+     JOIN pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, write_lag, flush_lag, replay_lag, sync_priority, sync_state) ON ((s.pid = w.pid)))
      LEFT JOIN pg_authid u ON ((s.usesysid = u.oid)));
 pg_stat_ssl| SELECT s.pid,
     s.ssl,