[PATCH proxmox 9/9] proxmox-log: add LogThrottle implementation

[Shan Shaji <s.shaji@proxmox.com>]

factor out LogThrottle implementation from pbs-client to proxmox-log
crate.

Signed-off-by: Shan Shaji <s.shaji@proxmox.com>
---
 proxmox-log/src/lib.rs          |  1 +
 proxmox-log/src/log_throttle.rs | 39 +++++++++++++++++++++++++++++++++
 2 files changed, 40 insertions(+)
 create mode 100644 proxmox-log/src/log_throttle.rs

diff --git a/proxmox-log/src/lib.rs b/proxmox-log/src/lib.rs
index 2d321f20..e82ab258 100644
--- a/proxmox-log/src/lib.rs
+++ b/proxmox-log/src/lib.rs
@@ -14,6 +14,7 @@ mod pve_task_formatter;
 mod tasklog_layer;
 
 pub mod builder;
+pub mod log_throttle;
 pub use builder::Logger;
 pub use file_logger::{FileLogOptions, FileLogger};
 
diff --git a/proxmox-log/src/log_throttle.rs b/proxmox-log/src/log_throttle.rs
new file mode 100644
index 00000000..e88e116f
--- /dev/null
+++ b/proxmox-log/src/log_throttle.rs
@@ -0,0 +1,39 @@
+use std::time::{Duration, Instant};
+
+pub const INITIAL_INTERVAL: Duration = Duration::from_secs(5);
+pub const MAX_INTERVAL: Duration = Duration::from_secs(60);
+
+/// Rate-limits recurring log output, such as progress lines, with an exponential backoff.
+///
+/// [`should_log`](Self::should_log) returns `true` at most once per the current interval. Starting
+/// from an initial interval, the delay doubles after each hit up to a configured maximum, giving
+/// frequent feedback early on while avoiding log spam during long-running operations.
+pub struct LogThrottle {
+    last: Instant,
+    interval: Duration,
+    max_interval: Duration,
+}
+
+impl LogThrottle {
+    /// Creates a throttle with the given initial interval, doubling up to `max_interval` after each
+    /// hit. The initial interval is capped at `max_interval`.
+    pub fn new(initial_interval: Duration, max_interval: Duration) -> Self {
+        Self {
+            last: Instant::now(),
+            interval: initial_interval.min(max_interval),
+            max_interval,
+        }
+    }
+
+    /// Returns `true` if the current interval has elapsed since the last hit, advancing the
+    /// throttle and doubling the interval (capped at the maximum); returns `false` otherwise.
+    pub fn should_log(&mut self) -> bool {
+        let now = Instant::now();
+        if now.duration_since(self.last) < self.interval {
+            return false;
+        }
+        self.last = now;
+        self.interval = (self.interval * 2).min(self.max_interval);
+        true
+    }
+}
-- 
2.47.3