shoryuken 7.0.1 → 7.0.3

data/lib/shoryuken/launcher.rb

@@ -43,8 +43,7 @@ module Shoryuken
       # Don't await here so the timeout below is not delayed
       stop_new_dispatching
 
-      executor.shutdown
-      executor.kill unless executor.wait_for_termination(Shoryuken.options[:timeout])
+      shutdown_executor
 
       fire_event(:stopped)
     end
@@ -61,8 +60,7 @@ module Shoryuken
       stop_new_dispatching
       await_dispatching_in_progress
 
-      executor.shutdown
-      executor.wait_for_termination
+      shutdown_executor
 
       fire_event(:stopped)
     end
@@ -93,11 +91,29 @@ module Shoryuken
       @managers.each(&:await_dispatching_in_progress)
     end
 
+    # Shuts the executor down, giving in-flight workers up to the configured
+    # timeout to finish before force-killing them so the process can exit.
+    # Used by both the graceful ({#stop}) and immediate ({#stop!}) shutdowns:
+    # a graceful stop still waits for workers, but must not block forever on a
+    # hung one.
+    #
+    # @return [void]
+    def shutdown_executor
+      executor.shutdown
+      executor.kill unless executor.wait_for_termination(Shoryuken.options[:timeout])
+    end
+
     # Returns the executor for running async operations
     #
+    # Owns a dedicated executor rather than borrowing Concurrent.global_io_executor:
+    # {#stop} and {#stop!} shut down and kill this executor, and destroying the
+    # process-global pool would break anything else relying on it (including
+    # Shoryuken's own ShoryukenConcurrentSendAdapter) and prevent a fresh launcher
+    # from starting in the same process.
+    #
     # @return [Concurrent::ExecutorService] the executor service
     def executor
-      @_executor ||= Shoryuken.launcher_executor || Concurrent.global_io_executor
+      @_executor ||= Shoryuken.launcher_executor || Concurrent::CachedThreadPool.new(auto_terminate: true)
     end
 
     # Starts all managers in parallel futures

data/lib/shoryuken/manager.rb

@@ -57,6 +57,9 @@ module Shoryuken
       # There might still be a dispatching on-going, as the response from SQS could take some time
       # We don't want to stop the process before processing incoming messages, as they would stay "in-flight" for some time on SQS
       # We use a queue, as the dispatch_loop is running on another thread, and this is a efficient way of communicating between threads.
+      # The dispatch loop closes the queue when it observes the stop flag; pop on a closed queue
+      # returns immediately, so this stays safe when stop is requested more than once
+      # (e.g. TSTP followed by USR1, which both trigger a graceful stop).
       @dispatching_release_signal.pop
     end
 
@@ -74,11 +77,23 @@ module Shoryuken
     # @return [void]
     def dispatch_loop
       if @stop_new_dispatching.true? || !running?
-        @dispatching_release_signal << 1
+        # Close (instead of push) so every pending and future
+        # await_dispatching_in_progress call returns, not just the first one
+        @dispatching_release_signal.close
         return
       end
 
       @executor.post { dispatch }
+    rescue Concurrent::RejectedExecutionError
+      # The executor was shut down between the running? check and the post
+      # (e.g. a hard stop racing the dispatch loop); release any waiters as
+      # the dispatch chain ends here
+      @dispatching_release_signal.close
+    rescue StandardError
+      # Unexpected error from post (e.g. ThreadError if the OS thread limit is
+      # hit); the dispatch chain ends here so release waiters before re-raising
+      @dispatching_release_signal.close
+      raise
     end
 
     # Dispatches messages from a queue
@@ -129,6 +144,12 @@ module Shoryuken
       return unless @polling_strategy.respond_to?(:message_processed)
 
       @polling_strategy.message_processed(queue)
+    rescue => e
+      # Swallow (but log) failures from the SQS lookups or the strategy callback:
+      # the busy counter was already decremented above and the caller's ensure
+      # must not run completion twice
+      logger.error { "Processor completion failed for #{queue}: #{e.message}" }
+      logger.debug { e.backtrace.join("\n") } unless e.backtrace.nil?
     end
 
     # Assigns a message to a processor
@@ -144,6 +165,11 @@ module Shoryuken
       @busy_processors.increment
       fire_utilization_update_event
 
+      # Completion runs in an ensure so it executes exactly once whether
+      # processing succeeds or raises. The previous `.then { processor_done }
+      # .rescue { processor_done }` chain ran completion twice when
+      # processor_done itself raised, double decrementing the busy counter
+      # and silently breaking the concurrency limit
       Concurrent::Promise
         .execute(executor: @executor) do
           original_priority = Thread.current.priority
@@ -152,10 +178,9 @@ module Shoryuken
             Processor.process(queue_name, sqs_msg)
           ensure
             Thread.current.priority = original_priority
+            processor_done(queue_name)
           end
         end
-        .then { processor_done(queue_name) }
-        .rescue { processor_done(queue_name) }
     end
 
     # Dispatches a batch of messages from a queue
@@ -208,9 +233,17 @@ module Shoryuken
       logger.error { "Manager failed: #{ex.message}" }
       logger.error { ex.backtrace.join("\n") } unless ex.backtrace.nil?
 
-      Process.kill('USR1', Process.pid)
-
+      # Stop this manager first so Launcher#healthy? surfaces the failure to
+      # whoever is supervising us (the CLI Runner, or an embedding application).
       @running.make_false
+
+      # In server (CLI) mode the Runner traps USR1 and turns it into a graceful
+      # shutdown of the whole process, so a process supervisor can restart us.
+      # When embedded (no Runner), USR1 keeps its default disposition and would
+      # terminate the host process - and any in-flight workers - so we must not
+      # send it. The stopped manager above is enough for Launcher#healthy? to
+      # report the failure to the embedding application.
+      Process.kill('USR1', Process.pid) if Shoryuken.server?
     end
 
     # Fires a utilization update event

data/lib/shoryuken/middleware/server/auto_extend_visibility.rb

@@ -48,8 +48,17 @@ module Shoryuken
           # @return [Shoryuken::Helpers::TimerTask] the timer task
           def auto_extend(_worker, queue, sqs_msg, _body)
             queue_visibility_timeout = Shoryuken::Client.queues(queue).visibility_timeout
+            execution_interval = extension_interval(queue_visibility_timeout)
 
-            Shoryuken::Helpers::TimerTask.new(execution_interval: queue_visibility_timeout - EXTEND_UPFRONT_SECONDS) do
+            unless execution_interval
+              logger.warn do
+                "Not auto-extending visibility for #{queue}/#{sqs_msg.message_id}: queue visibility " \
+                "timeout (#{queue_visibility_timeout}s) is too short. Increase it to use auto_visibility_timeout."
+              end
+              return nil
+            end
+
+            Shoryuken::Helpers::TimerTask.new(execution_interval: execution_interval) do
               logger.debug do
                 "Extending message #{queue}/#{sqs_msg.message_id} visibility timeout by #{queue_visibility_timeout}s"
               end
@@ -61,6 +70,25 @@ module Shoryuken
               end
             end
           end
+
+          private
+
+          # Returns a positive interval at which to re-extend the message's
+          # visibility before it expires, or nil when the visibility timeout is
+          # too short to schedule one. Normally this is EXTEND_UPFRONT_SECONDS
+          # before expiry, but for short timeouts (<= EXTEND_UPFRONT_SECONDS) it
+          # falls back to half the timeout so the timer still fires in time
+          # instead of TimerTask raising on a non-positive interval.
+          #
+          # @param visibility_timeout [Integer] the queue's visibility timeout in seconds
+          # @return [Float, Integer, nil] the execution interval, or nil if too short
+          def extension_interval(visibility_timeout)
+            return nil if visibility_timeout <= 0
+
+            interval = visibility_timeout - EXTEND_UPFRONT_SECONDS
+            interval = visibility_timeout / 2.0 if interval <= 0
+            interval
+          end
         end
 
         # Creates and starts a visibility extension timer
@@ -71,7 +99,9 @@ module Shoryuken
         # @param body [Object] the parsed message body
         # @return [Shoryuken::Helpers::TimerTask] the started timer
         def auto_visibility_timer(worker, queue, sqs_msg, body)
-          MessageVisibilityExtender.new.auto_extend(worker, queue, sqs_msg, body).tap(&:execute)
+          timer = MessageVisibilityExtender.new.auto_extend(worker, queue, sqs_msg, body)
+          timer&.execute
+          timer
         end
       end
     end

data/lib/shoryuken/middleware/server/exponential_backoff_retry.rb

@@ -17,8 +17,8 @@ module Shoryuken
         # @param _body [Object] the parsed message body (unused)
         # @yield continues to the next middleware in the chain
         # @return [void]
-        # @raise [StandardError] re-raises the original exception if retry intervals are not configured
-        #   or if retry limit is exceeded
+        # @raise [StandardError] re-raises the original exception if retry intervals are not configured,
+        #   if retry limit is exceeded, or if the exception is classified as non-retryable
         def call(worker, _queue, sqs_msg, _body)
           return yield unless worker.class.exponential_backoff?
 
@@ -30,7 +30,12 @@ module Shoryuken
           started_at = Time.now
           yield
         rescue => e
-          retry_intervals = worker.class.get_shoryuken_options['retry_intervals']
+          worker_options = worker.class.get_shoryuken_options
+          retry_intervals = worker_options['retry_intervals']
+
+          # Non-retryable exceptions must not be backoff retried; re-raise so the
+          # NonRetryableException middleware can delete the message immediately.
+          raise if NonRetryableException.non_retryable?(e, worker_options['non_retryable_exceptions'])
 
           if retry_intervals.nil? || !handle_failure(sqs_msg, started_at, retry_intervals)
             # Re-raise the exception if the job is not going to be exponential backoff retried.

data/lib/shoryuken/middleware/server/non_retryable_exception.rb

@@ -28,6 +28,22 @@ module Shoryuken
       class NonRetryableException
         include Util
 
+        # Checks whether an exception is classified as non-retryable for a worker
+        #
+        # @param exception [Exception] the exception to classify
+        # @param non_retryable_exceptions [Array<Class>, #call, nil] the worker's
+        #   non_retryable_exceptions option: exception classes or a callable
+        # @return [Boolean] true if the exception must not be retried
+        def self.non_retryable?(exception, non_retryable_exceptions)
+          return false unless non_retryable_exceptions
+
+          if non_retryable_exceptions.respond_to?(:call)
+            !!non_retryable_exceptions.call(exception)
+          else
+            Array(non_retryable_exceptions).any? { |klass| exception.is_a?(klass) }
+          end
+        end
+
         # Processes a message and handles non-retryable exceptions
         #
         # @param worker [Object] the worker instance
@@ -41,14 +57,7 @@ module Shoryuken
         rescue => e
           non_retryable_exceptions = worker.class.get_shoryuken_options['non_retryable_exceptions']
 
-          return raise unless non_retryable_exceptions
-
-          if non_retryable_exceptions.respond_to?(:call)
-            return raise unless non_retryable_exceptions.call(e)
-          else
-            exception_classes = Array(non_retryable_exceptions)
-            return raise unless exception_classes.any? { |klass| e.is_a?(klass) }
-          end
+          return raise unless self.class.non_retryable?(e, non_retryable_exceptions)
 
           # Handle batch messages
           messages = sqs_msg.is_a?(Array) ? sqs_msg : [sqs_msg]

data/lib/shoryuken/options.rb

@@ -34,7 +34,8 @@ module Shoryuken
     # @return [Class] the executor class for running workers
     # @return [Shoryuken::WorkerRegistry] the registry for worker classes
     # @return [Array<#call>] handlers for processing exceptions
-    attr_accessor :active_job_queue_name_prefixing, :cache_visibility_timeout,
+    attr_accessor :active_job_queue_name_prefixing, :active_job_fifo_message_deduplication,
+                  :cache_visibility_timeout,
                   :groups, :launcher_executor, :reloader, :enable_reloading,
                   :start_callback, :stop_callback, :worker_executor, :worker_registry,
                   :exception_handlers
@@ -53,6 +54,7 @@ module Shoryuken
       self.worker_registry = DefaultWorkerRegistry.new
       self.exception_handlers = [DefaultExceptionHandler]
       self.active_job_queue_name_prefixing = false
+      self.active_job_fifo_message_deduplication = true
       self.worker_executor = Worker::DefaultExecutor
       self.cache_visibility_timeout = false
       self.reloader = proc { |&block| block.call }
@@ -73,14 +75,21 @@ module Shoryuken
     # @param group [String] the name of the group
     # @param concurrency [Integer, nil] the number of concurrent workers for the group
     # @param delay [Float, nil] the delay between polling cycles
+    # @param polling_strategy [Class, String, nil] the polling strategy class for the group
     # @return [Hash] the group configuration
-    def add_group(group, concurrency = nil, delay: nil)
+    # @raise [Errors::InvalidPollingStrategyError] if polling_strategy is not a Class, String, or nil
+    def add_group(group, concurrency = nil, delay: nil, polling_strategy: nil)
+      unless polling_strategy.nil? || polling_strategy.is_a?(Class) || polling_strategy.is_a?(String)
+        raise Errors::InvalidPollingStrategyError, "#{polling_strategy} is not a valid polling_strategy"
+      end
+
       concurrency ||= options[:concurrency]
       delay ||= options[:delay]
 
       groups[group] ||= {
         concurrency: concurrency,
         delay: delay,
+        polling_strategy: polling_strategy,
         queues: []
       }
     end
@@ -109,7 +118,8 @@ module Shoryuken
     # @param group [String] the name of the group
     # @return [Class] the polling strategy class to use
     def polling_strategy(group)
-      strategy = (group == 'default' ? options : options[:groups].to_h[group]).to_h[:polling_strategy]
+      strategy = groups[group].to_h[:polling_strategy] ||
+                 (group == 'default' ? options : options[:groups].to_h[group]).to_h[:polling_strategy]
       case strategy
       when 'WeightedRoundRobin', nil # Default case
         Polling::WeightedRoundRobin
@@ -294,6 +304,15 @@ module Shoryuken
       @active_job_queue_name_prefixing
     end
 
+    # Checks if the ActiveJob adapter should auto-generate a content-based
+    # message_deduplication_id for FIFO queues. When disabled, distinct enqueues
+    # of the same job class and arguments are no longer silently deduplicated.
+    #
+    # @return [Boolean] true if FIFO deduplication id generation is enabled
+    def active_job_fifo_message_deduplication?
+      @active_job_fifo_message_deduplication
+    end
+
     private
 
     # Creates the default server middleware chain

data/lib/shoryuken/polling/strict_priority.rb

@@ -22,6 +22,10 @@ module Shoryuken
                         .each_with_object({}) { |queue, h| h[queue] = Time.at(0) }
 
         @delay = delay
+        # next_queue/messages_found run on the dispatch thread while
+        # message_processed runs on processor-completion threads (for FIFO
+        # queues), so all access to the shared state is serialized.
+        @mutex = Mutex.new
         # Start queues at 0
         reset_next_queue
       end
@@ -30,8 +34,10 @@ module Shoryuken
       #
       # @return [QueueConfiguration, nil] the next queue configuration or nil if all paused
       def next_queue
-        next_queue = next_active_queue
-        next_queue.nil? ? nil : QueueConfiguration.new(next_queue, {})
+        @mutex.synchronize do
+          next_queue = next_active_queue
+          next_queue.nil? ? nil : QueueConfiguration.new(next_queue, {})
+        end
       end
 
       # Handles the result of polling a queue
@@ -40,10 +46,12 @@ module Shoryuken
       # @param messages_found [Integer] number of messages found
       # @return [void]
       def messages_found(queue, messages_found)
-        if messages_found == 0
-          pause(queue)
-        else
-          reset_next_queue
+        @mutex.synchronize do
+          if messages_found == 0
+            pause(queue)
+          else
+            reset_next_queue
+          end
         end
       end
 
@@ -51,11 +59,13 @@ module Shoryuken
       #
       # @return [Array<Array>] array of [queue_name, priority] pairs
       def active_queues
-        @queues
-          .reverse
-          .map.with_index(1)
-          .reject { |q, _| queue_paused?(q) }
-          .reverse
+        @mutex.synchronize do
+          @queues
+            .reverse
+            .map.with_index(1)
+            .reject { |q, _| queue_paused?(q) }
+            .reverse
+        end
       end
 
       # Called when a message from a queue has been processed
@@ -63,9 +73,11 @@ module Shoryuken
       # @param queue [String] the queue name
       # @return [void]
       def message_processed(queue)
-        if queue_paused?(queue)
-          logger.debug "Unpausing #{queue}"
-          @paused_until[queue] = Time.at 0
+        @mutex.synchronize do
+          if queue_paused?(queue)
+            logger.debug "Unpausing #{queue}"
+            @paused_until[queue] = Time.at(0)
+          end
         end
       end
 

data/lib/shoryuken/polling/weighted_round_robin.rb

@@ -15,18 +15,26 @@ module Shoryuken
         @queues = queues.dup.uniq
         @paused_queues = []
         @delay = delay
+        # next_queue/messages_found run on the dispatch thread while
+        # message_processed runs on processor-completion threads (for FIFO
+        # queues), so all access to the shared state is serialized.
+        @mutex = Mutex.new
       end
 
       # Returns the next queue to poll in round-robin order
       #
       # @return [QueueConfiguration, nil] the next queue configuration or nil if all paused
       def next_queue
-        unpause_queues
-        queue = @queues.shift
-        return nil if queue.nil?
-
-        @queues << queue
-        QueueConfiguration.new(queue, {})
+        @mutex.synchronize do
+          unpause_queues
+          queue = @queues.shift
+          if queue.nil?
+            nil
+          else
+            @queues << queue
+            QueueConfiguration.new(queue, {})
+          end
+        end
       end
 
       # Handles the result of polling a queue, adjusting weight if messages were found
@@ -35,16 +43,17 @@ module Shoryuken
       # @param messages_found [Integer] number of messages found
       # @return [void]
       def messages_found(queue, messages_found)
-        if messages_found == 0
-          pause(queue)
-          return
-        end
-
-        maximum_weight = maximum_queue_weight(queue)
-        current_weight = current_queue_weight(queue)
-        if maximum_weight > current_weight
-          logger.info { "Increasing #{queue} weight to #{current_weight + 1}, max: #{maximum_weight}" }
-          @queues << queue
+        @mutex.synchronize do
+          if messages_found == 0
+            pause(queue)
+          else
+            maximum_weight = maximum_queue_weight(queue)
+            current_weight = current_queue_weight(queue)
+            if maximum_weight > current_weight
+              logger.info { "Increasing #{queue} weight to #{current_weight + 1}, max: #{maximum_weight}" }
+              @queues << queue
+            end
+          end
         end
       end
 
@@ -52,7 +61,7 @@ module Shoryuken
       #
       # @return [Array<Array>] array of [queue_name, weight] pairs
       def active_queues
-        unparse_queues(@queues)
+        @mutex.synchronize { unparse_queues(@queues) }
       end
 
       # Called when a message from a queue has been processed
@@ -60,10 +69,10 @@ module Shoryuken
       # @param queue [String] the queue name
       # @return [void]
       def message_processed(queue)
-        paused_queue = @paused_queues.find { |_time, name| name == queue }
-        return unless paused_queue
-
-        paused_queue[0] = Time.at 0
+        @mutex.synchronize do
+          paused_queue = @paused_queues.find { |_time, name| name == queue }
+          paused_queue[0] = Time.at(0) if paused_queue
+        end
       end
 
       private
@@ -79,16 +88,21 @@ module Shoryuken
         logger.debug "Paused #{queue}"
       end
 
-      # Unpauses queues whose delay has expired
+      # Unpauses the first queue whose delay has expired.
+      #
+      # Scans for any expired entry rather than only the head of the list:
+      # message_processed marks a queue ready by setting its time to the epoch,
+      # and that entry may sit behind an earlier-paused queue that is still
+      # paused - checking only the head would leave the ready queue stuck.
       #
       # @return [void]
       def unpause_queues
-        return if @paused_queues.empty?
-        return if Time.now < @paused_queues.first[0]
+        index = @paused_queues.index { |time, _name| time <= Time.now }
+        return if index.nil?
 
-        pause = @paused_queues.shift
-        @queues << pause[1]
-        logger.debug "Unpaused #{pause[1]}"
+        paused = @paused_queues.delete_at(index)
+        @queues << paused[1]
+        logger.debug "Unpaused #{paused[1]}"
       end
 
       # Returns the current weight of a queue in the active rotation

data/lib/shoryuken/queue.rb

@@ -52,11 +52,18 @@ module Shoryuken
       failed_messages = client.delete_message_batch(
         options.merge(queue_url: url)
       ).failed || []
-      failed_messages.any? do |failure|
+
+      # Log every failure (not just the first) and return a plain boolean.
+      # The previous `any? { logger.error ... }` short-circuited after the first
+      # failure - so the rest went unlogged - and only returned truthy because
+      # Logger#error happens to return true.
+      failed_messages.each do |failure|
         logger.error do
           "Could not delete #{failure.id}, code: '#{failure.code}', message: '#{failure.message}', sender_fault: #{failure.sender_fault}"
         end
       end
+
+      failed_messages.any?
     end
 
     # Sends a single message to the queue

data/lib/shoryuken/util.rb

@@ -20,7 +20,10 @@ module Shoryuken
     def fire_event(event, reverse = false, event_options = {})
       logger.debug { "Firing '#{event}' lifecycle event" }
       arr = Shoryuken.options[:lifecycle_events][event]
-      arr.reverse! if reverse
+      # reverse (not reverse!) so the stored handler array keeps its original
+      # order: events fired more than once with reverse: true (e.g. :shutdown
+      # via stop then stop!) must not alternate their handler order.
+      arr = arr.reverse if reverse
       arr.each do |block|
         block.call(event_options)
       rescue => e

data/lib/shoryuken/version.rb

@@ -2,5 +2,5 @@
 
 module Shoryuken
   # Current version of the Shoryuken gem
-  VERSION = '7.0.1'
+  VERSION = '7.0.3'
 end

data/lib/shoryuken/worker.rb

@@ -224,7 +224,11 @@ module Shoryuken
       #
       # @example Configuring exponential backoff
       #   shoryuken_options retry_intervals: [1, 5, 25, 125, 625]
-      #   # Will retry after 1s, 5s, 25s, 125s, then 625s before giving up
+      #   # Retries after 1s, 5s, 25s, 125s, then 625s for every later attempt.
+      #   # Shoryuken does not stop retrying on its own once the intervals are
+      #   # exhausted - it keeps reusing the last interval. Configure an SQS
+      #   # redrive policy (maxReceiveCount) to send exhausted messages to a
+      #   # dead-letter queue.
       #
       # @see #shoryuken_options Documentation for configuring retry_intervals
       def exponential_backoff?

data/lib/shoryuken.rb

@@ -58,6 +58,8 @@ module Shoryuken
     :stop_callback=,
     :active_job_queue_name_prefixing?,
     :active_job_queue_name_prefixing=,
+    :active_job_fifo_message_deduplication?,
+    :active_job_fifo_message_deduplication=,
     :sqs_client,
     :sqs_client=,
     :sqs_client_receive_message_opts,

data/renovate.json

@@ -4,6 +4,16 @@
     "config:recommended"
   ],
   "minimumReleaseAge": "7 days",
+  "includePaths": [
+    ".ruby-version",
+    "Gemfile",
+    "Gemfile.lint",
+    "shoryuken.gemspec",
+    "spec/gemfiles/**",
+    "spec/integration/**/Gemfile",
+    ".github/workflows/**",
+    "docker-compose.yml"
+  ],
   "github-actions": {
     "enabled": true,
     "pinDigests": true
@@ -46,7 +56,21 @@
         "ruby/setup-ruby",
         "ruby"
       ],
-      "groupName": "ruby setup"
+      "groupName": "ruby setup",
+      "internalChecksFilter": "strict"
+    },
+    {
+      "description": "Let setup-ruby pass age gate before ruby so it is ready when the group PR is created",
+      "matchPackageNames": [
+        "ruby/setup-ruby"
+      ],
+      "minimumReleaseAge": "5 days"
     }
-  ]
+  ],
+  "lockFileMaintenance": {
+    "enabled": true,
+    "schedule": [
+      "before 4am on the first day of the month"
+    ]
+  }
 }

data/spec/integration/active_job/bulk_enqueue/bulk_enqueue_spec.rb

@@ -3,7 +3,7 @@
 # Bulk enqueue integration test
 # Tests perform_all_later with the new enqueue_all method using SQS batch API
 
-setup_localstack
+setup_sqs
 setup_active_job
 
 queue_name = DT.queue

data/spec/integration/active_job/current_attributes/bulk_enqueue_spec.rb

@@ -2,7 +2,7 @@
 
 # CurrentAttributes are persisted correctly when using bulk enqueue (perform_all_later)
 
-setup_localstack
+setup_sqs
 setup_active_job
 
 require 'active_support/current_attributes'

data/spec/integration/active_job/current_attributes/complex_types_spec.rb

@@ -2,7 +2,7 @@
 
 # CurrentAttributes with complex data types (hashes, arrays, symbols) are serialized and restored
 
-setup_localstack
+setup_sqs
 setup_active_job
 
 require 'active_support/current_attributes'