toiler 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0be5aeacdc4416fc5d665387f5e5e8858c81b99f00cf63e58c71753f706f1d5d
-  data.tar.gz: 4a2d016c5b7a44cecce56076c02e058cb37952620be0d5a55b59fba8291f2316
+  metadata.gz: 6565dc34ea694f3407a7bf58108134a277197f1e145990749e0de7cb53f9d02f
+  data.tar.gz: 13f9b2aa0c289b4e66098e942c15ef79e402db53ccd67fd8b06bafba0c292377
 SHA512:
-  metadata.gz: 52222e17b30a37eb7a136a9114d44b263be27a16e085cbd35f0cff7a56618e206fc92da937fa20dce37cd23e5447f7c3a2b997197ce5b9c64acc4a4baecf48c0
-  data.tar.gz: 30d5b088632efa45bb91f4c885efdbe71a3f828b21230fa0cce03e29295fd0941569f9ec54f5af37ffeb2eebaae08a42b7d5a10e797e86b8129ec920c74cc4e7
+  metadata.gz: 34ca2858e5a70f8cf0187a93f3d32d98b28153d4b184aa89d42534ca6aeed5cabd514b4e7b92d24fe88900f623f23fc39ad6e991f0852676c1f250a60add0032
+  data.tar.gz: 8c719d64993aa04ea0e3e3f9e794c9c97a1925c776187f87f398f30df7ae266ef2235b0e103560c4cacbdb32223cc923175299f7f50fc4d27c670216dad9e294

data/.rubocop.yml

@@ -0,0 +1,29 @@
+# Documentation:
+#   Enabled: false
+# 
+# Style/ClassAndModuleChildren:
+#   Enabled: false
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 20
+
+Metrics/AbcSize:
+  Max: 40
+
+Metrics/ClassLength:
+  CountComments: false
+  Max: 200
+
+AllCops:
+  Exclude:
+    - 'vendor/**/*'
+    - 'tmp/**/*'
+    - 'config/**/*'
+    - 'bin/**'
+    - 'db/**/*'
+    - 'spec/**/*'
+  NewCops: enable
+  TargetRubyVersion: 2.6

data/.ruby-version

@@ -1 +1 @@
-2.2.2
+2.6.8

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec

data/Gemfile.lock

@@ -1,60 +1,148 @@
 PATH
   remote: .
   specs:
-    toiler (0.5.1.pre7)
+    toiler (0.7.0)
       aws-sdk-sqs (>= 1.0.0, < 2.0.0)
       concurrent-ruby (~> 1.0, >= 1.0.0)
       concurrent-ruby-edge (~> 0.3, >= 0.3)
+      google-cloud-pubsub (~> 2.9, >= 2.9.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    ast (2.4.0)
-    aws-eventstream (1.0.1)
-    aws-partitions (1.105.0)
-    aws-sdk-core (3.31.0)
-      aws-eventstream (~> 1.0)
-      aws-partitions (~> 1.0)
-      aws-sigv4 (~> 1.0)
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    ast (2.4.2)
+    aws-eventstream (1.2.0)
+    aws-partitions (1.573.0)
+    aws-sdk-core (3.130.0)
+      aws-eventstream (~> 1, >= 1.0.2)
+      aws-partitions (~> 1, >= 1.525.0)
+      aws-sigv4 (~> 1.1)
       jmespath (~> 1.0)
-    aws-sdk-sqs (1.7.0)
-      aws-sdk-core (~> 3, >= 3.26.0)
-      aws-sigv4 (~> 1.0)
-    aws-sigv4 (1.0.3)
-    concurrent-ruby (1.0.5)
-    concurrent-ruby-edge (0.3.1)
-      concurrent-ruby (= 1.0.5)
-    diff-lcs (1.3)
-    jaro_winkler (1.5.1)
-    jmespath (1.4.0)
-    parallel (1.12.1)
-    parser (2.5.1.2)
-      ast (~> 2.4.0)
-    powerpack (0.1.2)
-    rainbow (3.0.0)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.0)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.1)
+    aws-sdk-sqs (1.51.0)
+      aws-sdk-core (~> 3, >= 3.127.0)
+      aws-sigv4 (~> 1.1)
+    aws-sigv4 (1.4.0)
+      aws-eventstream (~> 1, >= 1.0.2)
+    concurrent-ruby (1.1.10)
+    concurrent-ruby-edge (0.6.0)
+      concurrent-ruby (~> 1.1.6)
+    diff-lcs (1.5.0)
+    faraday (1.10.0)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0)
+      faraday-multipart (~> 1.0)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.0)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      faraday-retry (~> 1.0)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-multipart (1.0.3)
+      multipart-post (>= 1.2, < 3)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    faraday-retry (1.0.3)
+    gapic-common (0.8.0)
+      faraday (~> 1.3)
+      google-protobuf (~> 3.14)
+      googleapis-common-protos (>= 1.3.11, < 2.a)
+      googleapis-common-protos-types (>= 1.0.6, < 2.a)
+      googleauth (>= 0.17.0, < 2.a)
+      grpc (~> 1.36)
+    google-cloud-core (1.6.0)
+      google-cloud-env (~> 1.0)
+      google-cloud-errors (~> 1.0)
+    google-cloud-env (1.6.0)
+      faraday (>= 0.17.3, < 3.0)
+    google-cloud-errors (1.2.0)
+    google-cloud-pubsub (2.9.1)
+      concurrent-ruby (~> 1.1)
+      google-cloud-core (~> 1.5)
+      google-cloud-pubsub-v1 (~> 0.0)
+    google-cloud-pubsub-v1 (0.8.0)
+      gapic-common (>= 0.7, < 2.a)
+      google-cloud-errors (~> 1.0)
+      grpc-google-iam-v1 (>= 0.6.10, < 2.a)
+    google-protobuf (3.20.0)
+    google-protobuf (3.20.0-x64-mingw32)
+    googleapis-common-protos (1.3.12)
+      google-protobuf (~> 3.14)
+      googleapis-common-protos-types (~> 1.2)
+      grpc (~> 1.27)
+    googleapis-common-protos-types (1.3.0)
+      google-protobuf (~> 3.14)
+    googleauth (1.1.2)
+      faraday (>= 0.17.3, < 3.a)
+      jwt (>= 1.4, < 3.0)
+      memoist (~> 0.16)
+      multi_json (~> 1.11)
+      os (>= 0.9, < 2.0)
+      signet (>= 0.16, < 2.a)
+    grpc (1.45.0)
+      google-protobuf (~> 3.19)
+      googleapis-common-protos-types (~> 1.0)
+    grpc (1.45.0-x64-mingw32)
+      google-protobuf (~> 3.19)
+      googleapis-common-protos-types (~> 1.0)
+    grpc-google-iam-v1 (1.0.0)
+      google-protobuf (~> 3.14)
+      googleapis-common-protos (>= 1.3.12, < 2.0)
+      grpc (~> 1.27)
+    jmespath (1.6.1)
+    jwt (2.3.0)
+    memoist (0.16.2)
+    multi_json (1.15.0)
+    multipart-post (2.1.1)
+    os (1.1.4)
+    parallel (1.22.1)
+    parser (3.1.1.0)
+      ast (~> 2.4.1)
+    public_suffix (4.0.6)
+    rainbow (3.1.1)
+    regexp_parser (2.2.1)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.0)
-    rubocop (0.58.2)
-      jaro_winkler (~> 1.5.1)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    rubocop (1.26.1)
       parallel (~> 1.10)
-      parser (>= 2.5, != 2.5.1.1)
-      powerpack (~> 0.1)
+      parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.16.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.0, >= 1.0.1)
-    ruby-progressbar (1.10.0)
-    unicode-display_width (1.4.0)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.16.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
+    signet (0.16.1)
+      addressable (~> 2.8)
+      faraday (>= 0.17.5, < 3.0)
+      jwt (>= 1.5, < 3.0)
+      multi_json (~> 1.10)
+    unicode-display_width (2.1.0)
 
 PLATFORMS
   ruby
@@ -66,4 +154,4 @@ DEPENDENCIES
   toiler!
 
 BUNDLED WITH
-   1.16.3
+   1.17.2

data/README.md

@@ -14,21 +14,17 @@ Instead of [shoryuken's](https://github.com/phstc/shoryuken) loadbalancing  appr
 ### Long-Polling
 
 A Fetcher thread is spawned for each queue.
-Fetchers are resposible for polling SQS and retreiving messages.
+Fetchers are resposible for polling SQS/PubSub and retreiving messages.
 They are optimised to not bring more messages than the amount of processors avaiable for such queue.
 By long-polling fetchers wait for a configurable amount of time for messages to become available on a single request, this prevents unneccesarilly requesting messages when there are none.
 
 ### Message Parsing
 
-Workers can configure a parser Class or Proc to parse an SQS message body before being processed.
+Workers can configure a parser Class or Proc to parse a message body before being processed.
 
-### Batches
+### Deadline Extension
 
-Toiler allows a Worker to be able to receive a batch of messages instead of a single one.
-
-### Auto Visibility Extension
-
-Toiler has the ability to automatically extend the visibility timeout of and SQS message to prevent the message from re-entering the queue if processing of such message is taking longer than the queue's visibility timeout.
+Toiler has the ability to automatically extend the ack deadline of and messages to prevent the message from re-entering the queue if processing of such message is taking longer than the queue's ack deadline or visibility timeout.
 
 ## Instalation
 
@@ -59,8 +55,9 @@ class MyWorker
 
   # toiler_options parser: ->(sqs_msg){ REXML::Document.new(sqs_msg.body) }
   # toiler_options parser: MultiJson
-  # toiler_options auto_visibility_timeout: true
+  # toiler_options deadline_extension: true
   # toiler_options batch: true
+  # toiler_options queue: 'subscription', concurrency: 5, auto_delete: true, provider: :gcp
 
   #Example connection client that should be shared across all instances of MyWorker
   @@client = ConnectionClient.new
@@ -82,10 +79,13 @@ end
 
 ```yaml
 aws:
-  access_key_id:      ...       # or <%= ENV['AWS_ACCESS_KEY_ID'] %>
-  secret_access_key:  ...       # or <%= ENV['AWS_SECRET_ACCESS_KEY'] %>
-  region:             us-east-1 # or <%= ENV['AWS_REGION'] %>
-wait: 20                        # The time in seconds to wait for messages during long-polling
+  access_key_id:     ...             # or <%= ENV['AWS_ACCESS_KEY_ID'] %>
+  secret_access_key: ...             # or <%= ENV['AWS_SECRET_ACCESS_KEY'] %>
+  region:            us-east-1       # or <%= ENV['AWS_REGION'] %>
+gcp:
+  project_id:  my-project            # or <%= ENV['GCP_PROJECT'] %>
+  credentials: /path/to/keyfile.json # or <%= ENV['GCP_CREDENTIALS'] %>
+wait: 20                             # The time in seconds to wait for messages during long-polling
 ```
 
 ### Rails Integration

data/Rakefile

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'

data/lib/toiler/actor/fetcher.rb

@@ -1,29 +1,32 @@
+# frozen_string_literal: true
+
 require 'toiler/actor/utils/actor_logging'
 require 'toiler/aws/queue'
+require 'toiler/gcp/queue'
 
 module Toiler
   module Actor
-    # Actor polling for messages only when processors are ready, otherwise idle
+    # Actor pulling messages only when processors are ready, otherwise idle
     class Fetcher < Concurrent::Actor::RestartingContext
       include Utils::ActorLogging
 
-      FETCH_LIMIT = 10
+      attr_reader :queue, :wait, :ack_deadline, :free_processors,
+                  :executing, :waiting_messages, :concurrency,
+                  :scheduled_task
 
-      attr_accessor :queue, :wait, :visibility_timeout, :free_processors,
-                    :executing, :waiting_messages, :concurrency
+      def initialize(queue_name, count, provider)
+        super()
 
-      def initialize(queue, client, count)
-        debug "Initializing Fetcher for queue #{queue}..."
-        @queue = Toiler::Aws::Queue.new queue, client
+        debug "Initializing Fetcher for queue #{queue_name} and provider #{provider}..."
         @wait = Toiler.options[:wait] || 60
         @free_processors = count
-        @batch = Toiler.worker_class_registry[queue].batch?
-        @visibility_timeout = @queue.visibility_timeout
         @executing = false
         @waiting_messages = 0
         @concurrency = count
-        debug "Finished initializing Fetcher for queue #{queue}"
-        tell :poll_messages
+        @scheduled_task = nil
+        init_queue(queue_name, provider)
+        debug "Finished initializing Fetcher for queue #{queue_name} and provider #{provider}..."
+        tell :pull_messages
       end
 
       def default_executor
@@ -35,8 +38,8 @@ module Toiler
         method, *args = msg
         send(method, *args)
       rescue StandardError, SystemStackError => e
-        # rescue SystemStackError, if we misbehave and cause a stack level too deep exception, we should be able to recover
-        error "Fetcher #{queue.name} raised exception #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+        # if we misbehave and cause a stack level too deep exception, we should be able to recover
+        error "Fetcher #{@queue.name} raised exception #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
       ensure
         @executing = false
       end
@@ -47,26 +50,26 @@ module Toiler
 
       private
 
-      def batch?
-        @batch
+      def init_queue(queue_name, provider)
+        if provider.nil? || provider.to_sym == :aws
+          @queue = Toiler::Aws::Queue.new queue_name, Toiler.aws_client
+        elsif provider.to_sym == :gcp
+          @queue = Toiler::Gcp::Queue.new queue_name, Toiler.gcp_client
+        else
+          raise StandardError, "unknown provider #{provider}"
+        end
+        @ack_deadline = @queue.ack_deadline
       end
 
       def processor_finished
-        debug "Fetcher #{queue.name} received processor finished signal..."
+        debug "Fetcher #{@queue.name} received processor finished signal..."
         @free_processors += 1
-        tell :poll_messages
-      end
-
-      def max_messages
-        batch? ? FETCH_LIMIT : [FETCH_LIMIT, free_processors].min
+        tell :pull_messages
       end
 
-      def poll_future(max_number_of_messages)
+      def pull_future(max_number_of_messages)
         Concurrent::Promises.future do
-          queue.receive_messages attribute_names: %w[All],
-                                 message_attribute_names: %w[All],
-                                 wait_time_seconds: wait,
-                                 max_number_of_messages: max_number_of_messages
+          @queue.receive_messages wait: @wait, max_messages: max_number_of_messages
         end
       end
 
@@ -74,49 +77,81 @@ module Toiler
         @waiting_messages -= messages
       end
 
-      def poll_messages
-        return unless should_poll?
+      def max_messages
+        # limit max messages to 10% of concurrency to always ensure we have
+        # 10 concurrent fetches and improved latency
+        [@queue.max_messages, (@concurrency * 0.1).ceil].min
+      end
+
+      def needed_messages
+        @free_processors - @waiting_messages
+      end
+
+      def pull_messages
+        if needed_messages < max_messages
+          # a pull is already scheduled and we dont fit a full batch, return
+          return unless @scheduled_task.nil?
+
+          free_percent = free_processors.to_f / concurrency
+          # wait time linear to the amount of free workers with a maximum of 5 seconds,
+          # when there are more free workers, we can theoretically wait more time, since
+          # we already have workers waiting for messages.
+          wait_time = 0.1 + (5 * free_percent)
+
+          # schedule a message pull if we cannot fill a batch
+          # this ensures we wait some time for more messages to arrive
+          @scheduled_task = Concurrent::ScheduledTask.execute(wait_time) do
+            tell [:do_pull_messages, true]
+          end
+        end
+
+        # we can fit a whole batch, if there was already a scheduled task
+        # we just let it run, it will only pull messages if there are more
+        # needed messages
+        do_pull_messages false
+      end
+
+      def do_pull_messages(clear_scheduled_task)
+        @scheduled_task = nil if clear_scheduled_task
 
-        max_number_of_messages = max_messages
-        return if waiting_messages > 0 && !full_batch?(max_number_of_messages)
+        return unless should_pull?
 
-        @waiting_messages += max_number_of_messages
+        current_needed_messages = needed_messages
 
-        debug "Fetcher #{queue.name} polling messages..."
-        future = poll_future max_number_of_messages
+        current_needed_messages = max_messages if current_needed_messages >= max_messages
+
+        @waiting_messages += current_needed_messages
+
+        debug "Fetcher #{@queue.name} pulling messages..."
+        future = pull_future current_needed_messages
         future.on_rejection! do
-          tell [:release_messages, max_number_of_messages]
-          tell :poll_messages
+          tell [:release_messages, current_needed_messages]
+          tell :pull_messages
         end
         future.on_fulfillment! do |msgs|
           tell [:assign_messages, msgs] if !msgs.nil? && !msgs.empty?
-          tell [:release_messages, max_number_of_messages]
-          tell :poll_messages
+          tell [:release_messages, current_needed_messages]
+          tell :pull_messages
         end
 
         # defer method execution to avoid recursion
-        tell :poll_messages if should_poll?
-      end
-
-      def should_poll?
-        free_processors / 2 > waiting_messages
+        tell :pull_messages if should_pull?
       end
 
-      def full_batch?(max_number_of_messages)
-        max_number_of_messages == FETCH_LIMIT || max_number_of_messages >= concurrency * 0.1
+      def should_pull?
+        needed_messages.positive?
       end
 
       def processor_pool
-        @processor_pool ||= Toiler.processor_pool queue.name
+        @processor_pool ||= Toiler.processor_pool @queue.name
       end
 
       def assign_messages(messages)
-        messages = [messages] if batch?
         messages.each do |m|
-          processor_pool.tell [:process, visibility_timeout, m]
+          processor_pool.tell [:process, @ack_deadline, m]
           @free_processors -= 1
         end
-        debug "Fetcher #{queue.name} assigned #{messages.count} messages"
+        debug "Fetcher #{@queue.name} assigned #{messages.count} messages"
       end
     end
   end

data/lib/toiler/actor/processor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'toiler/actor/utils/actor_logging'
 
@@ -7,10 +9,12 @@ module Toiler
     class Processor < Concurrent::Actor::RestartingContext
       include Utils::ActorLogging
 
-      attr_accessor :queue, :worker_class, :fetcher, :body_parser,
-                    :extend_callback, :executing, :thread
+      attr_reader :queue, :worker_class, :body_parser,
+                  :executing, :thread
 
       def initialize(queue)
+        super()
+
         @queue = queue
         @worker_class = Toiler.worker_class_registry[queue]
         @executing = false
@@ -23,15 +27,15 @@ module Toiler
       end
 
       def fetcher
-        @fetcher ||= Toiler.fetcher queue
+        @fetcher ||= Toiler.fetcher @queue
       end
 
       def on_message(msg)
         method, *args = msg
         send(method, *args)
       rescue StandardError, SystemStackError => e
-        # rescue SystemStackError, if clients misbehave and cause a stack level too deep exception, we should be able to recover
-        error "Processor #{queue} failed processing, reason: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+        # if clients misbehave and cause a stack level too deep exception, we should be able to recover
+        error "Processor #{@queue} failed processing, reason: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
       end
 
       def executing?
@@ -41,31 +45,30 @@ module Toiler
       private
 
       def init_options
-        @auto_visibility_timeout = @worker_class.auto_visibility_timeout?
+        @deadline_extension = @worker_class.auto_visibility_timeout? || @worker_class.deadline_extension?
         @auto_delete = @worker_class.auto_delete?
         toiler_options = @worker_class.toiler_options
         @body_parser = toiler_options[:parser]
-        @extend_callback = toiler_options[:on_visibility_extend]
       end
 
-      def auto_visibility_timeout?
-        @auto_visibility_timeout
+      def deadline_extension?
+        @deadline_extension
       end
 
       def auto_delete?
         @auto_delete
       end
 
-      def process(visibility, sqs_msg)
+      def process(ack_deadline, msg)
         process_init
         worker = @worker_class.new
-        body = get_body(sqs_msg)
-        timer = visibility_extender visibility, sqs_msg, body, &extend_callback
+        body = get_body(msg)
+        timer = deadline_extender ack_deadline, msg, body if deadline_extension?
 
-        debug "Worker #{queue} starts performing..."
-        worker.perform sqs_msg, body
-        debug "Worker #{queue} finishes performing..."
-        sqs_msg.delete if auto_delete?
+        debug "Worker #{@queue} starts performing..."
+        worker.perform msg, body
+        debug "Worker #{@queue} finishes performing..."
+        msg.delete if auto_delete?
       ensure
         process_cleanup timer
       end
@@ -73,56 +76,51 @@ module Toiler
       def process_init
         @executing = true
         @thread = Thread.current
-        debug "Processor #{queue} begins processing..."
+        debug "Processor #{@queue} begins processing..."
       end
 
       def process_cleanup(timer)
-        debug "Processor #{queue} starts cleanup after perform..."
-        timer.shutdown if timer
+        debug "Processor #{@queue} starts cleanup after perform..."
+        timer&.shutdown
         ::ActiveRecord::Base.clear_active_connections! if defined? ActiveRecord
         processor_finished
         @executing = false
         @thread = nil
-        debug "Processor #{queue} finished cleanup after perform..."
+        debug "Processor #{@queue} finished cleanup after perform..."
       end
 
       def processor_finished
         fetcher.tell :processor_finished
       end
 
-      def visibility_extender(queue_visibility, sqs_msg, body)
-        return unless auto_visibility_timeout?
-
-        interval = [1, queue_visibility / 3].max
-        Concurrent::TimerTask.execute execution_interval: interval,
-                                      timeout_interval: interval do |task|
-          begin
-            sqs_msg.visibility_timeout = queue_visibility
-            yield sqs_msg, body if block_given?
-          rescue StandardError => e
-            error "Processor #{queue} failed to extend visibility of message - #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
-            task.shutdown if e.message.include?('ReceiptHandle is invalid')
-          end
+      def deadline_extender(ack_deadline, msg, _body)
+        interval = [1, ack_deadline / 3].max
+        Concurrent::TimerTask.execute execution_interval: interval do |task|
+          msg.modify_ack_deadline! ack_deadline
+        rescue StandardError => e
+          error "Processor #{@queue} failed to extend ack deadline of message " \
+                "- #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+          task.shutdown if e.message.include?('ReceiptHandle is invalid')
         end
       end
 
-      def get_body(sqs_msg)
-        if sqs_msg.is_a? Array
-          sqs_msg.map { |m| parse_body m }
+      def get_body(msg)
+        if msg.is_a? Array
+          msg.map { |m| parse_body m }
         else
-          parse_body sqs_msg
+          parse_body msg
         end
       end
 
-      def parse_body(sqs_msg)
-        case body_parser
-        when :json then JSON.parse sqs_msg.body
-        when Proc then body_parser.call sqs_msg
-        when :text, nil then sqs_msg.body
-        else body_parser.load sqs_msg.body
+      def parse_body(msg)
+        case @body_parser
+        when :json then JSON.parse msg.body
+        when Proc then @body_parser.call msg
+        when :text, nil then msg.body
+        else @body_parser.load msg.body
         end
       rescue StandardError => e
-        raise "Error parsing the message body: #{e.message}"
+        raise "Error parsing the message body: #{e.message} - #{msg.body}"
       end
     end
   end