fix: pace SQLite lock retries

Yield between deadline-aware lock attempts so a contended caller does not hammer SQLite while preserving the original sync deadline. Assert bounded retry pressure without re-executing actor behavior.

Author: cardmagic

lib/solid_objects/database_adapters/sqlite.rb

@@ -3,6 +3,10 @@
 module SolidObjects
   module DatabaseAdapters
     class Sqlite < DatabaseAdapter
+      LOCK_RETRY_INTERVAL = 0.001
+      LOCK_RETRY_MUTEX = Thread::Mutex.new
+      LOCK_RETRY_CONDITION = Thread::ConditionVariable.new
+
       # @rbs () -> String
       def current_time_expression
         "STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')"
@@ -27,7 +31,7 @@ def with_lock_retry
       rescue DatabaseDeadlineExceeded
         raise if SyncDeadline.expired?
 
-        yield_before_retry
+        wait_before_retry
         retry
       rescue => error
         raise unless deadline_error?(error)
@@ -38,7 +42,7 @@ def with_lock_retry
             cause: error
         end
 
-        yield_before_retry
+        wait_before_retry
         retry
       end
 
@@ -84,8 +88,13 @@ def deadline_error?(error)
       end
 
       # @rbs () -> void
-      def yield_before_retry
-        Thread.pass
+      def wait_before_retry
+        LOCK_RETRY_MUTEX.synchronize do
+          LOCK_RETRY_CONDITION.wait(
+            LOCK_RETRY_MUTEX,
+            [ LOCK_RETRY_INTERVAL, SyncDeadline.remaining ].min
+          )
+        end
       end
     end
   end

sig/generated/lib/solid_objects/database_adapters/sqlite.rbs

@@ -3,6 +3,12 @@
 module SolidObjects
   module DatabaseAdapters
     class Sqlite < DatabaseAdapter
+      LOCK_RETRY_INTERVAL: ::Float
+
+      LOCK_RETRY_MUTEX: untyped
+
+      LOCK_RETRY_CONDITION: untyped
+
       # @rbs () -> String
       def current_time_expression: () -> String
 
@@ -24,7 +30,7 @@ module SolidObjects
       def deadline_error?: (Exception) -> bool
 
       # @rbs () -> void
-      def yield_before_retry: () -> void
+      def wait_before_retry: () -> void
     end
   end
 end

test/integration/synchronous_invocation_test.rb

@@ -2,6 +2,7 @@
 
 require "database_test_helper"
 require "solid_objects/mailbox"
+require "solid_objects/synchronous_invocation"
 require "timeout"
 
 class SynchronousInvocationTest < ActiveSupport::TestCase
@@ -483,11 +484,13 @@ def wait(timeout:)
     )
     lock = hold_sqlite_write_lock
 
-    error, elapsed = invoke_with_immediate_sqlite_lock_failure(message_reference)
+    error, elapsed, attempts = invoke_with_immediate_sqlite_lock_failure(message_reference)
 
     assert_instance_of SolidObjects::SyncTimeout, error
     assert_equal message_reference.id, error.message_id
     assert_operator elapsed, :<, 0.5
+    assert_operator attempts, :>, 1
+    assert_operator attempts, :<, 200
     assert_equal 0, LockRetryActor.executions
 
     release_sqlite_write_lock(lock)
@@ -512,11 +515,13 @@ def wait(timeout:)
     )
     lock = hold_sqlite_write_lock
 
-    error, elapsed = invoke_with_immediate_sqlite_lock_failure(message_reference)
+    error, elapsed, attempts = invoke_with_immediate_sqlite_lock_failure(message_reference)
 
     assert_instance_of SolidObjects::SyncTimeout, error
     assert_equal message_reference.id, error.message_id
     assert_operator elapsed, :<, 0.5
+    assert_operator attempts, :>, 1
+    assert_operator attempts, :<, 200
     assert_equal 0, LockRetryActor.executions
 
     release_sqlite_write_lock(lock)
@@ -758,6 +763,10 @@ def invoke_with_immediate_sqlite_lock_failure(message_reference)
     invocation = Thread.new do
       error = nil
       elapsed = nil
+      attempts = 0
+      subscription = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+        attempts += 1 if process_write?(event.payload)
+      end
       SolidObjects::Record.connection_pool.with_connection do |connection|
         previous_timeout = connection.select_value("PRAGMA busy_timeout").to_i
         connection.execute("PRAGMA busy_timeout = 0")
@@ -768,14 +777,20 @@ def invoke_with_immediate_sqlite_lock_failure(message_reference)
         elapsed = monotonic_now - started_at
       ensure
         connection.execute("PRAGMA busy_timeout = #{previous_timeout}")
+        ActiveSupport::Notifications.unsubscribe(subscription)
       end
-      result << [ error, elapsed ]
+      result << [ error, elapsed, attempts ]
     end
     captured = Timeout.timeout(2) { result.pop }
     invocation.join
     captured
   end
 
+  def process_write?(payload)
+    payload.fetch(:sql).match?(/\A(?:INSERT|UPDATE)/) &&
+      payload.fetch(:sql).include?(SolidObjects::Process.table_name)
+  end
+
   def actor_instance(actor_id)
     SolidObjects::Instance.find_by!(
       actor_type: "synchronous-counter",