honker 0.3.0 → 0.3.2

data/ext/honker/honker-core/src/lib.rs

@@ -24,7 +24,7 @@
 //!     acquire, non-blocking try_acquire, and release.
 //!   - [`Readers`] — bounded pool of reader connections that open
 //!     lazily up to a max.
-//!   - [`UpdateWatcher`] — 1 ms PRAGMA-polling thread that fires a
+//!   - [`UpdateWatcher`] — PRAGMA-polling thread that fires a
 //!     callback on every database commit. Uses `PRAGMA data_version`
 //!     for precise change detection, with a periodic stat identity check
 //!     to detect file replacement. Bindings wrap this to surface wake
@@ -59,13 +59,13 @@ use std::time::{Duration, Instant};
 
 /// Which backend drives the update-detection loop.
 ///
-/// `Polling` is the default: 1 ms `PRAGMA data_version` loop, proven
+/// `Polling` is the default: `PRAGMA data_version` loop, proven
 /// correct across all platforms. The optional backends are **experimental**
 /// — they must first prove equivalence to the polling path before
 /// being relied on for correctness.
 #[derive(Debug, Clone, Default)]
 pub enum WatcherBackend {
-    /// Default: 1 ms `PRAGMA data_version` polling loop.
+    /// Default: `PRAGMA data_version` polling loop.
     #[default]
     Polling,
     /// OS kernel filesystem notifications (experimental).
@@ -89,11 +89,40 @@ pub enum WatcherBackend {
     ShmFastPath,
 }
 
+pub const DEFAULT_WATCHER_POLL_INTERVAL: Duration = Duration::from_millis(1);
+
 /// Configuration passed to [`UpdateWatcher::spawn_with_config`] and
 /// [`SharedUpdateWatcher::new_with_config`].
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct WatcherConfig {
     pub backend: WatcherBackend,
+    pub poll_interval: Duration,
+}
+
+impl Default for WatcherConfig {
+    fn default() -> Self {
+        Self {
+            backend: WatcherBackend::default(),
+            poll_interval: DEFAULT_WATCHER_POLL_INTERVAL,
+        }
+    }
+}
+
+impl WatcherConfig {
+    pub fn with_backend(backend: WatcherBackend) -> Self {
+        Self {
+            backend,
+            ..Self::default()
+        }
+    }
+
+    pub fn with_poll_interval(mut self, poll_interval: Duration) -> Result<Self, String> {
+        if poll_interval.is_zero() {
+            return Err("watcher poll interval must be positive".to_string());
+        }
+        self.poll_interval = poll_interval;
+        Ok(self)
+    }
 }
 
 impl WatcherBackend {
@@ -318,7 +347,8 @@ pub const BOOTSTRAP_HONKER_SQL: &str = "
       priority INTEGER NOT NULL DEFAULT 0,
       expires_s INTEGER,
       next_fire_at INTEGER NOT NULL,
-      enabled INTEGER NOT NULL DEFAULT 1
+      enabled INTEGER NOT NULL DEFAULT 1,
+      max_attempts INTEGER NOT NULL DEFAULT 3
     );
     CREATE TABLE IF NOT EXISTS _honker_results (
       job_id INTEGER PRIMARY KEY,
@@ -378,6 +408,23 @@ pub fn bootstrap_honker_schema(conn: &Connection) -> Result<(), Error> {
             Err(e) => return Err(e.into()),
         }
     }
+    // Migration: max_attempts on scheduler tasks (per-fire job budget).
+    let has_max_attempts: bool = {
+        let mut stmt = conn.prepare(
+            "SELECT 1 FROM pragma_table_info('_honker_scheduler_tasks') WHERE name='max_attempts'",
+        )?;
+        stmt.query_row([], |_| Ok(true)).unwrap_or(false)
+    };
+    if !has_max_attempts {
+        match conn.execute(
+            "ALTER TABLE _honker_scheduler_tasks ADD COLUMN max_attempts INTEGER NOT NULL DEFAULT 3",
+            [],
+        ) {
+            Ok(_) => {}
+            Err(e) if e.to_string().to_lowercase().contains("duplicate column") => {}
+            Err(e) => return Err(e.into()),
+        }
+    }
     Ok(())
 }
 
@@ -538,14 +585,28 @@ impl Readers {
                 *out += 1;
                 drop(out);
                 drop(pool);
-                let conn = open_conn(&self.path, false)?;
-                // Re-check: if close() raced us, drop the brand-new
-                // connection instead of handing it out.
-                if self.closed.load(Ordering::Acquire) {
-                    drop(conn);
-                    return Err(closed_err());
+                match open_conn(&self.path, false) {
+                    Ok(conn) => {
+                        // Re-check: if close() raced us, drop the
+                        // brand-new connection instead of handing it
+                        // out. Release the capacity slot so a later
+                        // open after a failed race doesn't think the
+                        // pool is full forever.
+                        if self.closed.load(Ordering::Acquire) {
+                            *self.outstanding.lock() -= 1;
+                            drop(conn);
+                            return Err(closed_err());
+                        }
+                        return Ok(conn);
+                    }
+                    Err(e) => {
+                        // Open failed — free the slot we reserved or
+                        // every transient open failure permanently
+                        // shrinks max_readers until the pool is dead.
+                        *self.outstanding.lock() -= 1;
+                        return Err(e);
+                    }
                 }
-                return Ok(conn);
             }
             drop(out);
             self.available.wait(&mut pool);
@@ -680,9 +741,9 @@ fn is_transient_lock_error(e: &rusqlite::Error) -> bool {
 ///
 /// Three-layer defensive architecture:
 ///
-/// 1. **Fast path (every 1 ms):** `PRAGMA data_version`. Compare the
+/// 1. **Fast path:** `PRAGMA data_version`. Compare the
 ///    integer to last seen value. Notify on change. (~3.5 µs/call.)
-/// 2. **Error recovery (every 1 ms on failure):** If the query fails,
+/// 2. **Error recovery:** If the query fails,
 ///    reconnect the SQLite connection and force one wake.
 /// 3. **Identity check (about every 100 ms):** `stat(db_path)` to compare
 ///    `(dev, ino)`. If the file was replaced, panic with a clear
@@ -692,6 +753,7 @@ pub(crate) fn run_poll_loop<F>(
     on_change: F,
     stop: Arc<AtomicBool>,
     ready: std::sync::mpsc::SyncSender<()>,
+    poll_interval: Duration,
 ) where
     F: Fn(),
 {
@@ -724,7 +786,7 @@ pub(crate) fn run_poll_loop<F>(
     drop(ready);
 
     while !stop.load(Ordering::Acquire) {
-        std::thread::sleep(Duration::from_millis(1));
+        std::thread::sleep(poll_interval);
 
         // Path 1: PRAGMA data_version (fast path)
         if let Some(ref c) = conn {
@@ -836,7 +898,9 @@ impl UpdateWatcher {
         let handle = std::thread::Builder::new()
             .name("honker-update-poll".into())
             .spawn(move || match config.backend {
-                WatcherBackend::Polling => run_poll_loop(db_path, on_change, stop_t, ready_tx),
+                WatcherBackend::Polling => {
+                    run_poll_loop(db_path, on_change, stop_t, ready_tx, config.poll_interval)
+                }
                 #[cfg(feature = "kernel-watcher")]
                 WatcherBackend::KernelWatch => {
                     kernel_watcher::run_kernel_watch_loop(db_path, on_change, stop_t, ready_tx);
@@ -1243,6 +1307,7 @@ mod tests {
                 |r| r.get(0),
             )
             .unwrap();
+        // Enqueue / stream_publish must NOT write synthetic wake rows.
         let enqueue_wakes: i64 = conn
             .query_row(
                 "SELECT COUNT(*) FROM _honker_notifications WHERE channel='honker:pressure'",
@@ -1250,6 +1315,13 @@ mod tests {
                 |r| r.get(0),
             )
             .unwrap();
+        let stream_wakes: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM _honker_notifications WHERE channel='honker:stream:pressure-events'",
+                [],
+                |r| r.get(0),
+            )
+            .unwrap();
         let integrity: String = conn
             .query_row("PRAGMA integrity_check", [], |r| r.get(0))
             .unwrap();
@@ -1257,7 +1329,14 @@ mod tests {
         assert_eq!(dead, 0);
         assert_eq!(stream_rows as usize, total_jobs);
         assert_eq!(notes as usize, total_jobs);
-        assert_eq!(enqueue_wakes as usize, total_jobs);
+        assert_eq!(
+            enqueue_wakes, 0,
+            "enqueue must not write wake notifications"
+        );
+        assert_eq!(
+            stream_wakes, 0,
+            "stream_publish must not write wake notifications"
+        );
         assert_eq!(integrity, "ok");
 
         drop(conn);
@@ -2253,6 +2332,7 @@ while True:
                 "expires_s",
                 "next_fire_at",
                 "enabled",
+                "max_attempts",
             ],
         );
         let res_cols: Vec<String> = conn
@@ -2329,6 +2409,7 @@ while True:
             },
             WatcherConfig {
                 backend: WatcherBackend::KernelWatch,
+                ..WatcherConfig::default()
             },
         );
 
@@ -2407,6 +2488,7 @@ while True:
             },
             WatcherConfig {
                 backend: WatcherBackend::ShmFastPath,
+                ..WatcherConfig::default()
             },
         );
 
@@ -2487,7 +2569,7 @@ while True:
             move || {
                 count_t.fetch_add(1, AO::Relaxed);
             },
-            WatcherConfig { backend },
+            WatcherConfig::with_backend(backend),
         );
 
         // Drain init wakes (covers shm + kernel setup) before baseline.
@@ -2704,7 +2786,7 @@ while True:
                     .expect("wake_times mutex poisoned")
                     .push(std::time::Instant::now());
             },
-            WatcherConfig { backend },
+            WatcherConfig::with_backend(backend),
         );
 
         // Drain initialization wakes.
@@ -2768,7 +2850,10 @@ while True:
         ignore = "notify/kqueue can drop the watcher thread under CI load; functional kernel watcher tests still run"
     )]
     #[cfg(feature = "kernel-watcher")]
-    #[cfg_attr(target_os = "macos", ignore = "kqueue under CI load may deliver zero wakes")]
+    #[cfg_attr(
+        target_os = "macos",
+        ignore = "kqueue under CI load may deliver zero wakes"
+    )]
     fn kernel_watcher_wake_latency_is_event_driven() {
         let tmp = std::env::temp_dir().join(format!(
             "honker-kw-lat-{}-{}",
@@ -2872,6 +2957,7 @@ while True:
             || {},
             WatcherConfig {
                 backend: WatcherBackend::KernelWatch,
+                ..WatcherConfig::default()
             },
         );
 
@@ -2931,6 +3017,14 @@ while True:
         ));
     }
 
+    #[test]
+    fn watcher_config_rejects_zero_poll_interval() {
+        let err = WatcherConfig::default()
+            .with_poll_interval(Duration::from_millis(0))
+            .unwrap_err();
+        assert_eq!(err, "watcher poll interval must be positive");
+    }
+
     #[test]
     #[cfg(not(feature = "kernel-watcher"))]
     fn watcher_backend_parse_rejects_uncompiled_kernel() {
@@ -3062,8 +3156,11 @@ while True:
             f.write_all(&buf).unwrap();
         }
 
-        let watcher =
-            UpdateWatcher::spawn_with_config(tmp.clone(), || {}, WatcherConfig { backend });
+        let watcher = UpdateWatcher::spawn_with_config(
+            tmp.clone(),
+            || {},
+            WatcherConfig::with_backend(backend),
+        );
         // Generous initial wait so the watcher has snapshotted the
         // initial inode under CI scheduling pressure.
         std::thread::sleep(Duration::from_millis(300));
@@ -3113,4 +3210,98 @@ while True:
             "expected probe to fail for inaccessible dir, got Ok"
         );
     }
+
+    #[test]
+    fn readers_open_failure_does_not_leak_capacity() {
+        // Path under a missing directory — open_conn fails every time.
+        // Without the outstanding decrement on open failure, two
+        // failures with max=2 permanently fill the counter and the
+        // third acquire blocks forever on the condvar.
+        let r = Arc::new(Readers::new(
+            "/this/parent/does/not/exist/honker-readers-leak.db".into(),
+            2,
+        ));
+        for i in 0..5 {
+            let r = r.clone();
+            let handle = std::thread::spawn(move || r.acquire());
+            let result = handle.join().expect("acquire thread panicked");
+            assert!(
+                result.is_err(),
+                "attempt {i}: expected open failure, got Ok"
+            );
+        }
+    }
+
+    #[test]
+    fn claim_batch_dead_letters_reclaim_past_max_attempts() {
+        // Worker dies without retry/ack after the last allowed claim.
+        // The next claim must dead-letter the row, not reclaim it.
+        let path = temp_db("claim-max-attempts");
+        let conn = open_core_test_conn(&path);
+
+        let job_id: i64 = conn
+            .query_row(
+                "SELECT honker_enqueue('q', '{\"n\":1}', NULL, NULL, 0, 2, NULL)",
+                [],
+                |r| r.get(0),
+            )
+            .unwrap();
+
+        // Claim 1 → attempts=1. Expire visibility.
+        let claimed1: String = conn
+            .query_row("SELECT honker_claim_batch('q', 'w1', 1, 30)", [], |r| {
+                r.get(0)
+            })
+            .unwrap();
+        assert!(claimed1.contains(&format!("\"id\":{job_id}")));
+        conn.execute(
+            "UPDATE _honker_live SET claim_expires_at = unixepoch() - 1 WHERE id=?1",
+            rusqlite::params![job_id],
+        )
+        .unwrap();
+
+        // Claim 2 (reclaim) → attempts=2. Expire again.
+        let claimed2: String = conn
+            .query_row("SELECT honker_claim_batch('q', 'w2', 1, 30)", [], |r| {
+                r.get(0)
+            })
+            .unwrap();
+        assert!(claimed2.contains(&format!("\"id\":{job_id}")));
+        conn.execute(
+            "UPDATE _honker_live SET claim_expires_at = unixepoch() - 1 WHERE id=?1",
+            rusqlite::params![job_id],
+        )
+        .unwrap();
+
+        // Claim 3: exhausted → empty claim, row in dead.
+        let claimed3: String = conn
+            .query_row("SELECT honker_claim_batch('q', 'w3', 1, 30)", [], |r| {
+                r.get(0)
+            })
+            .unwrap();
+        assert_eq!(claimed3, "[]");
+
+        let live: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM _honker_live WHERE id=?1",
+                rusqlite::params![job_id],
+                |r| r.get(0),
+            )
+            .unwrap();
+        let (dead_attempts, last_error): (i64, String) = conn
+            .query_row(
+                "SELECT attempts, last_error FROM _honker_dead WHERE id=?1",
+                rusqlite::params![job_id],
+                |r| Ok((r.get(0)?, r.get(1)?)),
+            )
+            .unwrap();
+        assert_eq!(live, 0);
+        assert_eq!(dead_attempts, 2);
+        assert_eq!(last_error, "max attempts exceeded");
+
+        drop(conn);
+        let _ = std::fs::remove_file(&path);
+        let _ = std::fs::remove_file(format!("{}-wal", path.display()));
+        let _ = std::fs::remove_file(format!("{}-shm", path.display()));
+    }
 }

data/ext/honker/honker-extension/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "honker-extension"
-version = "0.2.3"
+version = "0.2.5"
 edition = "2024"
 description = "SQLite loadable extension for Honker. Adds honker_* SQL functions (queues, streams, scheduler, pub/sub) to any SQLite client."
 license = "MIT OR Apache-2.0"
@@ -23,7 +23,7 @@ crate-type = ["cdylib"]
 # Using both `path` and `version` lets Cargo publish this crate to
 # crates.io referencing the real honker-core = "0.2" while still
 # using the in-tree source for local builds.
-honker-core = { path = "../honker-core", version = "0.2.3", default-features = false }
+honker-core = { path = "../honker-core", version = "0.2.5", default-features = false }
 # "loadable_extension" feature makes rusqlite usable from inside a
 # sqlite3_extension_init entry point.
 rusqlite = { version = "0.39.0", features = ["functions", "hooks", "loadable_extension"] }

data/ext/honker/honker-extension/src/lib.rs

@@ -69,12 +69,17 @@ static NEXT_SQL_WATCHER_ID: AtomicU64 = AtomicU64::new(1);
 fn open_watcher_handle(
     db_path: &str,
     backend: Option<&str>,
+    watcher_poll_interval_ms: Option<u64>,
 ) -> std::result::Result<HonkerWatcherHandle, String> {
     let backend = honker_core::WatcherBackend::parse(backend.filter(|s| !s.is_empty()))?;
     backend.probe(PathBuf::from(db_path).as_path())?;
+    let mut config = honker_core::WatcherConfig::with_backend(backend);
+    if let Some(ms) = watcher_poll_interval_ms {
+        config = config.with_poll_interval(Duration::from_millis(ms))?;
+    }
     let shared = Arc::new(honker_core::SharedUpdateWatcher::new_with_config(
         PathBuf::from(db_path),
-        honker_core::WatcherConfig { backend },
+        config,
     ));
     let (sub_id, rx) = shared.subscribe();
     Ok(HonkerWatcherHandle { shared, sub_id, rx })
@@ -88,7 +93,7 @@ fn attach_watcher_sql_functions(conn: &Connection) -> Result<()> {
         |ctx| {
             let db_path: String = ctx.get(0)?;
             let backend: Option<String> = ctx.get(1)?;
-            let handle = open_watcher_handle(&db_path, backend.as_deref()).map_err(|e| {
+            let handle = open_watcher_handle(&db_path, backend.as_deref(), None).map_err(|e| {
                 rusqlite::Error::UserFunctionError(Box::new(std::io::Error::other(e)))
             })?;
             let id = NEXT_SQL_WATCHER_ID.fetch_add(1, Ordering::Relaxed);
@@ -96,6 +101,24 @@ fn attach_watcher_sql_functions(conn: &Connection) -> Result<()> {
             Ok(id as i64)
         },
     )?;
+    conn.create_scalar_function(
+        "honker_update_watcher_open",
+        3,
+        FunctionFlags::SQLITE_UTF8,
+        |ctx| {
+            let db_path: String = ctx.get(0)?;
+            let backend: Option<String> = ctx.get(1)?;
+            let poll_interval_ms: Option<i64> = ctx.get(2)?;
+            let poll_interval_ms = poll_interval_ms.map(|ms| ms.max(0) as u64);
+            let handle = open_watcher_handle(&db_path, backend.as_deref(), poll_interval_ms)
+                .map_err(|e| {
+                    rusqlite::Error::UserFunctionError(Box::new(std::io::Error::other(e)))
+                })?;
+            let id = NEXT_SQL_WATCHER_ID.fetch_add(1, Ordering::Relaxed);
+            SQL_WATCHERS.lock().unwrap().insert(id, handle);
+            Ok(id as i64)
+        },
+    )?;
     conn.create_scalar_function(
         "honker_update_watcher_wait",
         2,
@@ -266,7 +289,46 @@ pub unsafe extern "C" fn honker_watcher_open(
             .to_str()
             .map_err(|e| format!("invalid db_path UTF-8: {e}"))?;
         let backend = unsafe { cstr_to_string(backend) }?;
-        let handle = open_watcher_handle(path, backend.as_deref())?;
+        let handle = open_watcher_handle(path, backend.as_deref(), None)?;
+        Ok(Box::into_raw(Box::new(handle)))
+    })) {
+        Ok(Ok(ptr)) => ptr,
+        Ok(Err(err)) => {
+            unsafe { write_error(err_buf, err_buf_len, &err) };
+            ptr::null_mut()
+        }
+        Err(payload) => {
+            let err = panic_error(payload).to_string();
+            unsafe { write_error(err_buf, err_buf_len, &err) };
+            ptr::null_mut()
+        }
+    }
+}
+
+/// Open a core-backed update watcher over `db_path` with options.
+///
+/// `watcher_poll_interval_ms` must be positive. Use `honker_watcher_open`
+/// for the default 1 ms cadence.
+///
+/// # Safety
+/// All pointers must be valid NUL-terminated strings when non-null.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn honker_watcher_open_v2(
+    db_path: *const c_char,
+    backend: *const c_char,
+    watcher_poll_interval_ms: u64,
+    err_buf: *mut c_char,
+    err_buf_len: usize,
+) -> *mut HonkerWatcherHandle {
+    match catch_unwind(AssertUnwindSafe(|| {
+        if db_path.is_null() {
+            return Err("db_path is null".to_string());
+        }
+        let path = unsafe { CStr::from_ptr(db_path) }
+            .to_str()
+            .map_err(|e| format!("invalid db_path UTF-8: {e}"))?;
+        let backend = unsafe { cstr_to_string(backend) }?;
+        let handle = open_watcher_handle(path, backend.as_deref(), Some(watcher_poll_interval_ms))?;
         Ok(Box::into_raw(Box::new(handle)))
     })) {
         Ok(Ok(ptr)) => ptr,

data/lib/honker/lock.rb

@@ -56,11 +56,11 @@ module Honker
 
     # Extend the TTL. Returns true if we still hold the lock; false if
     # it was stolen (the TTL elapsed and another owner acquired it).
-    # The underlying SQL is the same as `try_lock`, but keyed on our
-    # existing `(name, owner)` pair so it refreshes rather than blocks.
+    # Uses honker_lock_renew — honker_lock_acquire does not refresh
+    # expires_at for an existing (name, owner) row.
     def heartbeat(ttl_s:)
       @db.db.get_first_row(
-        "SELECT honker_lock_acquire(?, ?, ?)",
+        "SELECT honker_lock_renew(?, ?, ?)",
         [@name, @owner, ttl_s],
       )[0] == 1
     end

data/lib/honker/scheduler.rb

@@ -43,13 +43,13 @@ module Honker
     #
     # Idempotent by `name`; registering the same name twice replaces
     # the previous row.
-    def add(name:, queue:, cron: nil, schedule: nil, payload:, priority: 0, expires_s: nil)
+    def add(name:, queue:, cron: nil, schedule: nil, payload:, priority: 0, expires_s: nil, max_attempts: 3)
       expr = schedule || cron
       raise ArgumentError, "must provide cron: or schedule:" if expr.nil? || expr.empty?
 
       @db.db.get_first_row(
-        "SELECT honker_scheduler_register(?, ?, ?, ?, ?, ?)",
-        [name, queue, expr, JSON.dump(payload), priority, expires_s],
+        "SELECT honker_scheduler_register(?, ?, ?, ?, ?, ?, ?)",
+        [name, queue, expr, JSON.dump(payload), priority, expires_s, max_attempts],
       )
       @db.mark_updated
       nil
@@ -105,7 +105,7 @@ module Honker
 
     # Return every registered schedule with current state. Each entry
     # is a Hash with: name, queue, cron_expr, payload (JSON string),
-    # priority, expires_s, next_fire_at, enabled.
+    # priority, expires_s, next_fire_at, enabled, max_attempts.
     def list
       raw = @db.db.get_first_row("SELECT honker_scheduler_list()")[0]
       return [] if raw.nil? || raw.empty?
@@ -115,9 +115,10 @@ module Honker
 
     # Mutate fields in place. Pass only the kwargs you want changed
     # (omitting a kwarg leaves the field alone). `payload: nil`
-    # writes JSON null. Cron change recomputes next_fire_at from now.
+    # writes JSON null; `max_attempts: nil` resets to default 3.
+    # Cron change recomputes next_fire_at from now.
     # Returns true iff a row was updated.
-    def update(name, schedule: UNSET, cron: UNSET, payload: UNSET, priority: UNSET, expires_s: UNSET)
+    def update(name, schedule: UNSET, cron: UNSET, payload: UNSET, priority: UNSET, expires_s: UNSET, max_attempts: UNSET)
       expr = nil
       expr = schedule if schedule != UNSET
       expr = cron if expr.nil? && cron != UNSET
@@ -126,13 +127,16 @@ module Honker
       priority_arg = (priority == UNSET) ? nil : priority
       touch_expires = (expires_s == UNSET) ? 0 : 1
       expires_arg = (expires_s == UNSET) ? nil : expires_s
+      touch_max_attempts = (max_attempts == UNSET) ? 0 : 1
+      max_attempts_arg = (max_attempts == UNSET) ? nil : max_attempts
 
-      any_field = !expr.nil? || payload != UNSET || priority != UNSET || expires_s != UNSET
+      any_field = !expr.nil? || payload != UNSET || priority != UNSET || expires_s != UNSET || max_attempts != UNSET
       return false unless any_field
 
       n = @db.db.get_first_row(
-        "SELECT honker_scheduler_update(?, ?, ?, ?, ?, ?)",
-        [name, expr, payload_arg, priority_arg, expires_arg, touch_expires],
+        "SELECT honker_scheduler_update(?, ?, ?, ?, ?, ?, ?, ?)",
+        [name, expr, payload_arg, priority_arg, expires_arg, touch_expires,
+         max_attempts_arg, touch_max_attempts],
       )[0]
       @db.mark_updated if n.positive?
       n.positive?
@@ -187,18 +191,15 @@ module Honker
     def leader_loop(owner, stop_fn)
       last_heartbeat = monotonic_now
       until stop_fn.call
+        still_ours = lock_renew(LEADER_LOCK, owner, LOCK_TTL_S)
+        # IMPORTANT: if refresh failed, a new leader has the lock.
+        # Break out before ticking so we don't double-fire.
+        return unless still_ours
+
+        last_heartbeat = monotonic_now
         # tick errors escape up to `run`, which releases the lock in
         # its `ensure` before re-raising.
         tick
-        if monotonic_now - last_heartbeat >= HEARTBEAT_S
-          still_ours = lock_try_acquire(LEADER_LOCK, owner, LOCK_TTL_S)
-          # IMPORTANT: if refresh failed, a new leader has the lock.
-          # Break out of the leader loop so we don't double-fire. This
-          # is the bug the Rust binding fixed; don't reintroduce it.
-          return unless still_ours
-
-          last_heartbeat = monotonic_now
-        end
 
         wait_s = HEARTBEAT_S - (monotonic_now - last_heartbeat)
         wait_s = 0 if wait_s.negative?
@@ -239,6 +240,13 @@ module Honker
       )[0] == 1
     end
 
+    def lock_renew(name, owner, ttl_s)
+      @db.db.get_first_row(
+        "SELECT honker_lock_renew(?, ?, ?)",
+        [name, owner, ttl_s],
+      )[0] == 1
+    end
+
     def lock_release(name, owner)
       @db.db.get_first_row(
         "SELECT honker_lock_release(?, ?)",

data/lib/honker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Honker
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end