tina4ruby 3.13.42 → 3.13.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdfe0b3f854e7ecea3419e6c10efe9e527be73952c8d570fb46106e0476255ec
-  data.tar.gz: 1c63029ec5a6e61fb91c7add6377735f6a8b740d0a416826333d400f493a623a
+  metadata.gz: 209245b1743578b21530e31feb670940f068cc911725fff1b2a59ee6d8335e10
+  data.tar.gz: '059d0fde8d4fbc57db9e4aa408d0dd31f71b1c8065d5041258a8a502017ce7ab'
 SHA512:
-  metadata.gz: 53d20a66c7f796f36befa7777c8e62cf494ff659ef0e9d8aa7f5b7cb078c2abef4c3fc4fe99bc61df797681212d3a91bdd73bf67e6be16a4cd4da15cf91c3f02
-  data.tar.gz: 93a184a4b081ad26a81162ac08d61b4ab6051dd1ea90097dfce1dbd177610d2154dc741eb77a0ca31a3d68eb3813dfea1f99801a92550e568450cd3e9a9a2869
+  metadata.gz: 30babc583e40444ec46069088e1af2a94f0485546b585530ccda22cca2a8ba29fafca3464bd08845fd1d9f88e92342533f2c58a82b89f38a517fce607096f905
+  data.tar.gz: 84960f5d44cb50d7ec4d8dd31a6645e10640526aaf6c9f777e81c7376a43290a6027d33d903f45a317f369834eee59518ec9d215d05e8933c820e5d3020ae49e

data/lib/tina4/queue.rb

@@ -305,6 +305,10 @@ module Tina4
         config = resolve_mongo_config
         config[:visibility_timeout] = vt
         config[:max_retries] = max_retries
+        # Thread retry_backoff through so a failed/retried job's available_at is
+        # reset to now (or now + retry_backoff) instead of being stranded for the
+        # full visibility window (Bug B).
+        config[:retry_backoff] = retry_backoff
         Tina4::QueueBackends::MongoBackend.new(config)
       else
         raise ArgumentError, "Unknown queue backend: #{chosen.inspect}. Use 'lite', 'rabbitmq', 'kafka', or 'mongodb'."

data/lib/tina4/queue_backends/mongo_backend.rb

@@ -5,11 +5,16 @@ module Tina4
     class MongoBackend
       # Reservation/visibility + retry policy (settable so a Queue can propagate
       # its own onto a backend instance passed directly — legacy path).
-      attr_accessor :visibility_timeout, :max_retries
+      attr_accessor :visibility_timeout, :max_retries, :retry_backoff
 
       def initialize(options = {})
         require "mongo"
         @max_retries = options[:max_retries] || 3
+        # Seconds to delay a requeued (failed/retried) job before it is eligible
+        # again. Default 0 = available on the very next dequeue, so a fail()'d job
+        # retries immediately (matching the lite backend) instead of waiting out
+        # the visibility window.
+        @retry_backoff = (options[:retry_backoff] || 0).to_f
 
         uri = options[:uri] || ENV["TINA4_MONGO_URI"]
         host = options[:host] || ENV.fetch("TINA4_MONGO_HOST", "localhost")
@@ -134,10 +139,58 @@ module Tina4
         collection.delete_one(_id: message.id)
       end
 
+      # Terminal success — the job is done and removed (mirrors the lite
+      # backend's complete()). Without this, job.complete() was a no-op on
+      # MongoDB and the document stayed "processing" forever.
+      def complete(message)
+        collection.delete_one(_id: message.id)
+      end
+
+      # Record a failed attempt (mirrors the lite backend + the Python Mongo
+      # adapter). Increments attempts; while attempts < max_retries the job is
+      # re-queued to pending (visible again immediately, or after retry_backoff),
+      # otherwise it is dead-lettered. The Queue/Job lifecycle expects fail() to
+      # route the requeue here — previously MongoBackend had no fail(), so
+      # job.fail() degraded to in-memory bookkeeping and never touched Mongo.
+      def fail(job, error = "")
+        job.attempts += 1
+        if job.attempts >= @max_retries
+          collection.find_one_and_update(
+            { _id: job.id },
+            { "$set" => { status: "dead", topic: "#{job.topic}.dead_letter",
+                          error: error, reserved_at: nil } },
+            upsert: true
+          )
+        else
+          requeue_with_error(job, error)
+        end
+      end
+
+      # Explicit re-queue requested by the caller (job.retry()). Always
+      # re-enqueues regardless of the retry limit — a manual override, distinct
+      # from the automatic fail() path. Increments attempts, clears the error.
+      def retry(job, delay_seconds: 0)
+        job.attempts += 1
+        backoff = delay_seconds.to_f > 0 ? delay_seconds.to_f : @retry_backoff
+        collection.find_one_and_update(
+          { _id: job.id },
+          { "$set" => { status: "pending", error: nil, reserved_at: nil,
+                        available_at: requeue_available_at(backoff) } },
+          upsert: true
+        )
+      end
+
       def requeue(message)
+        # Reset available_at so the requeued job is visible again right away (or
+        # after retry_backoff) and clear reserved_at. dequeue() pushed
+        # available_at out to the reservation expiry; leaving it there stranded a
+        # requeued job for the full visibility window instead of retrying it on
+        # the next pop().
         collection.find_one_and_update(
           { _id: message.id },
-          { "$set" => { status: "pending" }, "$inc" => { attempts: 1 } },
+          { "$set" => { status: "pending", reserved_at: nil,
+                        available_at: requeue_available_at(@retry_backoff) },
+            "$inc" => { attempts: 1 } },
           upsert: true
         )
       end
@@ -172,7 +225,11 @@ module Tina4
       def retry_failed(topic, max_retries: 3)
         result = collection.update_many(
           { topic: topic, status: "failed", attempts: { "$lt" => max_retries } },
-          { "$set" => { status: "pending" } }
+          # Reset available_at so re-queued failed jobs are visible again — they
+          # were reserved with available_at in the future at dequeue. Clear
+          # reserved_at too. (Same Bug B reason as requeue/fail.)
+          { "$set" => { status: "pending", error: nil, reserved_at: nil,
+                        available_at: requeue_available_at(@retry_backoff) } }
         )
         result.modified_count
       end
@@ -183,6 +240,31 @@ module Tina4
 
       private
 
+      # Re-queue a failed job to pending, carrying the failure reason and
+      # resetting available_at (now, or now + retry_backoff) + clearing
+      # reserved_at so the next dequeue picks it up.
+      def requeue_with_error(job, error)
+        collection.find_one_and_update(
+          { _id: job.id },
+          # Persist the incremented attempt count (fail() already did job.attempts
+          # += 1). Without this the doc's attempts stayed at its old value, so the
+          # next dequeue surfaced a stale count, fail()'s attempts >= max_retries
+          # check never tripped, and the job was re-queued forever instead of
+          # dead-lettering.
+          { "$set" => { status: "pending", error: error, reserved_at: nil,
+                        attempts: job.attempts,
+                        available_at: requeue_available_at(@retry_backoff) } },
+          upsert: true
+        )
+      end
+
+      # available_at for a re-queued job: now (immediately retryable) or
+      # now + backoff when a backoff is configured.
+      def requeue_available_at(backoff)
+        b = (backoff || 0).to_f
+        b > 0 ? (Time.now.utc + b) : Time.now.utc
+      end
+
       def collection
         @db[@collection_name]
       end

data/lib/tina4/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4
-  VERSION = "3.13.42"
+  VERSION = "3.13.43"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.42
+  version: 3.13.43
 platform: ruby
 authors:
 - Tina4 Team