fix(poller): wait for both wall clock and monotonic value

Signed-off-by: Babak K. Shandiz <babakks@github.com>

Author: babakks

device/poller.go

@@ -38,13 +38,57 @@ func (p *intervalPoller) SetInterval(d time.Duration) {
 }
 
 func (p *intervalPoller) Wait() error {
-	t := time.NewTimer(p.interval)
-	select {
-	case <-p.ctx.Done():
-		t.Stop()
-		return p.ctx.Err()
-	case <-t.C:
-		return nil
+	// We know that in virtualised environments (e.g. WSL or VMs), the monotonic
+	// clock, which is the source of time measurements in Go, can run faster than
+	// real time. So, polling intervals should be adjusted to avoid falling into
+	// an endless loop of "slow_down" errors from the server. See the following
+	// issue in cli/cli for more context (especially what's after this particular
+	// comment):
+	//   - https://github.com/cli/cli/issues/9370#issuecomment-3759706125
+	//
+	// We've observed ~10% faster ticking, thanks to community, but a chat with
+	// AI suggests it's typically between 5-15% on WSL, and can get up to 30% in
+	// worst cases. There are issues reported on the WSL repo, but I couldn't
+	// find any documented/conclusive data about this.
+	//
+	// See more:
+	//   - https://github.com/microsoft/WSL/issues/12583
+	//
+	// Although the wall clock is not a reliable source for time measurement, but
+	// using it we can spot any time drift. Here, we'll wait until both the wall
+	// clock and the monotonic value are past the intended wait time. To avoid
+	// falling into a convergence loop (i.e. getting smaller and smaller wait
+	// intervals), we have to limit the minimum wait interval to 1s.
+	//
+	// Although it's rare, but it's possible for the wall clock to be modified by
+	// the user or NTP adjustments during polling. To avoid being affected by
+	// large changes in the wall clock, we'll also cap the secondary wait time to
+	// the original polling interval.
+
+	tstop := time.Now().UnixNano() + int64(p.interval)
+	interval := p.interval
+
+	for {
+		select {
+		case <-p.ctx.Done():
+			return p.ctx.Err()
+		case now := <-time.After(interval):
+			diff := now.UnixNano() - tstop
+			if diff > 0 {
+				return nil
+			}
+
+			diff = -diff
+			if diff < int64(time.Second) {
+				// Keep a 1s minimum interval for secondary waits.
+				interval = time.Second
+			} else if diff > int64(p.interval) {
+				// Cap the secondary wait to the original interval.
+				interval = p.interval
+			} else {
+				interval = time.Duration(diff)
+			}
+		}
 	}
 }