eventq 4.0.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b478bb783830a9a72ec5aa1790edcce6e21dd1ca336ce0610841bdfba96072b
-  data.tar.gz: b75542f44bb89e77b9b4bd3175b872508c707efa17a30a288fea4e83cdea5b25
+  metadata.gz: c0bbacb646ab33aa08c10738ceeba304c17c0c5f80024b0b8c5e22cb4a11e41a
+  data.tar.gz: d05f206a2231a46750ab172426725dc7a7347acfd084c6371ea888955182042c
 SHA512:
-  metadata.gz: 8b823fbb7482330f56a50721a375ea8c6a92feaaff45dd1540454c02b0cc981aa4ecf78c76b219816498c58cb5e4df80432a03c955397dd1b461824e09d1d789
-  data.tar.gz: b335b2ecd2c8c1ce7758890816b5f9947c8d32dabd25a62e7e395e1f79c19cf3dce34aac5196117623833695e813650148745d01557466fbb731103abde31b84
+  metadata.gz: 8daf3d93b434bae5ca09c3d2c51e9058df10f3355efbfcf116bd44eb52fd4769209f90a5638204de5e9eff93b418f07596bd746d33db5510a5c5a3471fea1f7f
+  data.tar.gz: 2cf23e913f766e2f2dff17cb1ea47dfbb5b6c1f476728113225cf50801ade03dfcacdfec810a44a8ac2c3c50d84b3af2fc91bbbda1dda7ea5ea2eb324040e7c2

data/README.md

@@ -54,6 +54,7 @@ A subscription queue should be defined to receive any events raised for the subs
 
  - **allow_retry** [Bool] [Optional] [Default=false] This determines if the queue should allow processing failures to be retried.
  - **allow_retry_back_off** [Bool] [Optional] [Default=false] This is used to specify if failed messages that retry should incrementally backoff.
+ - **allow_exponential_back_off** [Bool] [Optional] [Default=false] This is used to specify if failed messages that retry should expontentially backoff.
  - **retry_back_off_grace** [Int] [Optional] [Default=0] This is the number of times to allow retries without applying retry back off if enabled.
  - **dlq** [EventQ::Queue] [Optional] [Default=nil] A queue that will receive the messages which were not successfully processed after maximum number of receives by consumers. This is created at the same time as the parent queue.
  - **max_retry_attempts** [Int] [Optional] [Default=5] This is used to specify the max number of times an event should be allowed to retry before failing.
@@ -63,21 +64,77 @@ A subscription queue should be defined to receive any events raised for the subs
  - **require_signature** [Bool] [Optional] [Default=false] This is used to specify if messages within this queue must be signed.
  - **retry_delay** [Int] [Optional] [Default=30000] This is used to specify the time delay in milliseconds before a failed message is re-added to the subscription queue.
  - **retry_back_off_weight** [Int] [Optional] [Default=1] Additional multiplier for the timeout backoff. Normally used when `retry_delay` is too small (eg: 30ms) in order to get meaningful backoff values.
+ - **retry_jitter_ratio** [Int] [Optional] [Default=0] Amount of randomness for retry delays in percent to avoid a bulk of retries hitting again at the same time. 0% means no randomness, while 100% means full randomness. With full randomness, a random number between 0 and the calculated retry delay will be chosen for the delay.
 
 **Example**
 
 ```ruby
-# Create a queue that allows retries and accepts a maximum of 3 retries with a 20 second delay between retries.
+# Create a queue that allows retries and accepts a maximum of 5 retries with a 20 second delay between retries.
 class DataChangeAddressQueue < Queue
   def initialize
     @name = 'Data.Change.Address'
     @allow_retry = true
-    @retry_delay = 20000
-    @max_retry_attempts = 3
+    @retry_delay = 20_000
+    @max_retry_attempts = 5
   end
 end
 ```
 
+**Retry Strategies**
+
+In distributed systems, it is expected for some events to fail.
+Thankfully, those events can be put "on hold" and will be processed again after a given waiting time.
+The attributes affecting your retry strategy the most are:
+* `retry_delay` (base duration that events are waiting before being reprocessed)
+* `max_receive_count` and `max_retry_attempts` (limiting how often an event can be seen / processed)
+* `allow_retry`, `allow_retry_back_off` and `allow_exponential_back_off` (defining if retries are allowed and how duration between retries should be calculated)
+
+If only `retry_delay` is set to `true`, while `allow_retry_back_off` and `allow_exponential_back_off` remain `false`, the duration between retries will be `retry_delay` each time ("fixed back off").
+So there is a fixed duration between events, like in the example for `DataChangeAddressQueue` above.
+With the configuration of that class, the event will be retried 5 times, with at least 20 seconds between retries.
+Therefore we can calculate that the final retry will have happened after `retry_duration * max_retry_attempts`, which results in 100 seconds here.
+
+If also `allow_retry_back_off` is set to `true`, the duration between retries will scale with the number of retries ("incremental back off").
+So the first retry will happen after `retry_duration`, the second after `2 * retry_duration`, the third after `3 * retry_duration` and so on.
+So the retries will be spread out further apart each time.
+The last retry will be processed after `(max_retry_attempts * (max_retry_attempts + 1))/2 * retry_duration`.
+So in the example above, it would result in 300 seconds until the last retry.
+
+If also `allow_exponential_back_off` is set to `true`, the duration between retries will double each time ("exponential back off").
+So the first retry will happen after `retry_duration`, the second after `2 * retry_duration`, the third after `4 * retry_duration` and so on.
+The last retry will be processed after `(2^max_retry_attempts - 1) * retry_duration`.
+So in the example above, it would result in 620 seconds until the last retry.
+
+You can run experiments on your retry configuration using [plot_visibility_timeout.rb](https://github.com/Sage/eventq/blob/master/utilities/plot_visibility_timeout.rb), which will output the retry duration on each retry given your settings.
+
+
+![Graph comparing back off strategies](images/back-off-strategy.png)
+
+**Randomness**
+
+By default, there will be no randomness in your retry strategy.
+However, that means that with a fixed 20 second back off, many events overloading your service will all come back after exactly 20 seconds, overloading it again.
+Therefore it can be useful to introduce randomness to your retry duration, so the events that initially hit the queue at the same time, are spread out when scheduling them for retry.
+
+The attribute `retry_jitter_ratio` allows you to configure how much randomness ("jitter") is allowed for the retry duration.
+Let's assume we have a `retry_duration = 20_000` (20 seconds).
+Then the `retry_jitter_ratio` would have the following effect:
+* 0 means no randomness, so retry duration of 20 seconds is used every time
+* 20 means 20% randomness, so the duration will be randomly chosen between 80% to 100% of the value, i.e. between 16 to 20 seconds
+* 50 means 50% randomness, i.e. between 10 to 20 seconds
+* 80 means 80% randomness, i.e. between 4 to 20 seconds
+* 100 means 100% randomness, i.e. between 0 to 20 seconds
+
+In the graphs below you can see how adding 50% randomness can help avoid overloading the service.
+In the first graph ("Fixed Retry Duration"), all failures are hitting the queue again after exactly 20 seconds.
+This leads to only a couple of events to succeed, as the others fail due to too many concurrent requests running into locks etc.
+However, in the second graph ("Randomised Retry Duration"), the events are randomnly spread out over the next 10 to 20 seconds.
+This means less events hit the service concurrently, allowing it to succesfully process more events and processing all of the events in a shorter duration, reducing the overall load on the service.
+
+![Graph showing that events overload the service repeatedly with fixed retry duration](images/fixed-retry-duration.png)
+
+![Graph showing that events are spread out on retries when randomising retry duration](images/randomised-retry-duration.png)
+
 ### SubscriptionManager
 
 In order to receive events within a subscription queue it must subscribe to the type of the event it should receive.
@@ -109,10 +166,10 @@ This method is called to unsubscribe a queue.
 
 **Example**
 
-    #create an instant of the queue definition
+    #create an instance of the queue definition
 	queue = DateChangeAddressQueue.new
 
-    #subscribe the queue definition to an event type
+    #unsubscribe the queue definition
     subscription_manager.unsubscribe(queue)
 
 
@@ -321,17 +378,17 @@ This method is called to verify connection to an event_type (topic/exchange).
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in  the file, `EVENTQ_VERSION`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+### Setup
 
+After checking out the repo, run `bin/setup` to install dependencies.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 ### Preparing the Docker images
 
 Run the setup script of eventq to build the environment. This will create the `eventq` image.
 
-    $ cd script
-    $ ./setup.sh
+    $ ./script/setup.sh
 
 ### Running the tests
 
@@ -345,13 +402,19 @@ You will also need to comment out the AWS_* environment variables in the `docker
 
 Run the whole test suite:
 
-    $ cd script
-    $ ./test.sh
+    $ ./script/test.sh
 
 You can run the specs that don't depend on an AWS account with:
 
-    $ cd script
-    $ ./test.sh --tag ~integration
+    $ ./script/test.sh --tag ~integration
+
+### Release new version
+
+To release a new version, first update the version number in  the file [`EVENTQ_VERSION`](https://github.com/Sage/eventq/blob/master/EVENTQ_VERSION).
+With that change merged to `master`, just [draft a new release](https://github.com/Sage/eventq/releases/new) with the same version you specified in `EVENTQ_VERSION`.
+Use "Generate Release Notes" to generate details for this release.
+
+This will create a git tag for the version and triggers the GitHub [Workflow to publish the new gem](https://github.com/Sage/eventq/actions/workflows/publish.yml) (defined in [publish.yml](https://github.com/Sage/eventq/blob/master/.github/workflows/publish.yml)) to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/lib/eventq/eventq_aws/aws_calculate_visibility_timeout.rb

@@ -5,7 +5,7 @@ module EventQ
     # Class responsible to know how to calculate message Visibility Timeout for Amazon SQS
     class CalculateVisibilityTimeout
       def initialize(max_timeout:, logger: EventQ.logger)
-        @max_timeout = max_timeout
+        @max_timeout = seconds_to_ms(max_timeout)
         @logger      = logger
       end
 
@@ -14,28 +14,33 @@ module EventQ
       # @param retry_attempts [Integer] Current retry
       # @param queue_settings [Hash] Queue settings
       # @option allow_retry_back_off [Bool] Enables/Disables backoff strategy
+      # @option allow_exponential_back_off [Bool] Enables/Disables exponential backoff strategy
       # @option max_retry_delay [Integer] Maximum amount of time a retry will take in ms
       # @option retry_back_off_grace [Integer] Amount of retries to wait before starting to backoff
       # @option retry_back_off_weight [Integer] Multiplier for the backoff retry
+      # @option retry_jitter_ratio [Integer] Ratio of how much jitter to apply to the backoff retry
       # @option retry_delay [Integer] Amount of time to wait until retry in ms
       # @return [Integer] the calculated visibility timeout in seconds
       def call(retry_attempts:, queue_settings:)
-        @retry_attempts       = retry_attempts
+        @retry_attempts = retry_attempts
 
-        @allow_retry_back_off = queue_settings.fetch(:allow_retry_back_off)
-        @max_retry_delay      = queue_settings.fetch(:max_retry_delay)
-        @retry_back_off_grace = queue_settings.fetch(:retry_back_off_grace)
-        @retry_back_off_weight= queue_settings.fetch(:retry_back_off_weight)
-        @retry_delay          = queue_settings.fetch(:retry_delay)
+        @allow_retry_back_off       = queue_settings.fetch(:allow_retry_back_off)
+        @allow_exponential_back_off = queue_settings.fetch(:allow_exponential_back_off)
+        @max_retry_delay            = queue_settings.fetch(:max_retry_delay)
+        @retry_back_off_grace       = queue_settings.fetch(:retry_back_off_grace)
+        @retry_back_off_weight      = queue_settings.fetch(:retry_back_off_weight)
+        @retry_jitter_ratio         = queue_settings.fetch(:retry_jitter_ratio)
+        @retry_delay                = queue_settings.fetch(:retry_delay)
 
-        if @allow_retry_back_off && retry_past_grace_period?
-          visibility_timeout = timeout_with_back_off
-          visibility_timeout = check_for_max_timeout(visibility_timeout)
+        visibility_timeout = if @allow_retry_back_off && retry_past_grace_period?
+          timeout_with_back_off
         else
-          visibility_timeout = timeout_without_back_off
+          timeout_without_back_off
         end
 
-        visibility_timeout
+        visibility_timeout = apply_jitter(visibility_timeout) if @retry_jitter_ratio > 0
+
+        ms_to_seconds(visibility_timeout)
       end
 
       private
@@ -47,34 +52,57 @@ module EventQ
       end
 
       def timeout_without_back_off
-        ms_to_seconds(@retry_delay)
+        @retry_delay
       end
 
       def timeout_with_back_off
         factor = @retry_attempts - @retry_back_off_grace
+        weighted_retry_delay = @retry_delay * @retry_back_off_weight
 
-        visibility_timeout = ms_to_seconds(@retry_delay * factor * @retry_back_off_weight)
-        max_retry_delay = ms_to_seconds(@max_retry_delay)
-
-        if visibility_timeout > max_retry_delay
-          logger.debug { "[#{self.class}] - Max message back off retry delay reached: #{max_retry_delay}" }
-          visibility_timeout = max_retry_delay
+        visibility_timeout = if @allow_exponential_back_off
+          weighted_retry_delay * 2 ** (factor - 1)
+        else
+          weighted_retry_delay * factor
         end
 
-        visibility_timeout
+        visibility_timeout = check_for_max_retry_delay(visibility_timeout)
+        check_for_max_timeout(visibility_timeout)
+      end
+
+      def apply_jitter(visibility_timeout)
+        ratio = @retry_jitter_ratio / 100.0
+        min_visibility_timeout = (visibility_timeout * (1 - ratio)).to_i
+        rand(min_visibility_timeout..visibility_timeout)
       end
 
       def ms_to_seconds(value)
         value / 1000
       end
 
+      def seconds_to_ms(value)
+        value * 1000
+      end
+
+      def check_for_max_retry_delay(visibility_timeout)
+        return visibility_timeout if visibility_timeout <= @max_retry_delay
+
+        logger.debug do
+          "[#{self.class}] - Max message back off retry delay reached: #{ms_to_seconds(@max_retry_delay)}"
+        end
+
+        @max_retry_delay
+      end
+
       def check_for_max_timeout(visibility_timeout)
-        if visibility_timeout > @max_timeout
-          logger.debug { "[#{self.class}] - AWS max visibility timeout of 12 hours has been exceeded. Setting message retry delay to 12 hours." }
-          visibility_timeout = @max_timeout
+        return visibility_timeout if visibility_timeout <= @max_timeout
+
+        logger.debug do
+          "[#{self.class}] - AWS max visibility timeout of 12 hours has been exceeded. "\
+          "Setting message retry delay to 12 hours."
         end
-        visibility_timeout
+
+        @max_timeout
       end
     end
   end
-end
+end

data/lib/eventq/eventq_aws/aws_queue_worker.rb

@@ -119,16 +119,7 @@ module EventQ
 
           EventQ.logger.warn("[#{self.class}] - Message Id: #{args.id}. Rejected requesting retry. Attempts: #{retry_attempts}")
 
-          visibility_timeout = @calculate_visibility_timeout.call(
-            retry_attempts:       retry_attempts,
-            queue_settings: {
-              allow_retry_back_off:  queue.allow_retry_back_off,
-              max_retry_delay:       queue.max_retry_delay,
-              retry_back_off_grace:  queue.retry_back_off_grace,
-              retry_back_off_weight: queue.retry_back_off_weight,
-              retry_delay:           queue.retry_delay
-            }
-          )
+          visibility_timeout = calculate_visibility_timeout(retry_attempts, queue)
 
           EventQ.logger.debug { "[#{self.class}] - Sending message for retry. Message TTL: #{visibility_timeout}" }
           poller.change_message_visibility_timeout(msg, visibility_timeout)
@@ -136,6 +127,21 @@ module EventQ
           context.call_on_retry_block(message)
         end
       end
+
+      def calculate_visibility_timeout(retry_attempts, queue)
+        @calculate_visibility_timeout.call(
+          retry_attempts: retry_attempts,
+          queue_settings: {
+            allow_retry_back_off:       queue.allow_retry_back_off,
+            allow_exponential_back_off: queue.allow_exponential_back_off,
+            max_retry_delay:            queue.max_retry_delay,
+            retry_back_off_grace:       queue.retry_back_off_grace,
+            retry_back_off_weight:      queue.retry_back_off_weight,
+            retry_jitter_ratio:         queue.retry_jitter_ratio,
+            retry_delay:                queue.retry_delay
+          }
+        )
+      end
     end
   end
 end

data/lib/eventq/eventq_base/nonce_manager.rb

@@ -1,10 +1,24 @@
 module EventQ
+  class NonceManagerNotConfiguredError < StandardError; end
+
   class NonceManager
 
-    def self.configure(server:,timeout:10000,lifespan:3600)
+    def self.configure(server:,timeout:10000,lifespan:3600, pool_size: 5, pool_timeout: 5)
       @server_url = server
       @timeout = timeout
       @lifespan = lifespan
+      @pool_size = pool_size
+      @pool_timeout = pool_timeout
+
+      @redis_pool = begin
+        require 'connection_pool'
+        require 'redis'
+
+        ConnectionPool.new(size: @pool_size, timeout: @pool_timeout) do
+          Redis.new(url: @server_url)
+        end
+      end
+      @configured = true
     end
 
     def self.server_url
@@ -19,39 +33,77 @@ module EventQ
       @lifespan
     end
 
-    def self.is_allowed?(nonce)
-      if @server_url == nil
-        return true
+    def self.pool_size
+      @pool_size
+    end
+
+    def self.pool_timeout
+      @pool_timeout
+    end
+
+    def self.lock(nonce)
+      # act as if successfully locked if not nonce manager configured - makes it a no-op
+      return true if !configured?
+
+      successfully_locked = false
+      with_redis_connection do |conn|
+        successfully_locked = conn.set(nonce, 1, ex: lifespan, nx: true)
       end
 
-      require 'redlock'
-      lock = Redlock::Client.new([ @server_url ]).lock(nonce, @timeout)
-      if lock == false
+      if !successfully_locked
         EventQ.log(:info, "[#{self.class}] - Message has already been processed: #{nonce}")
-        return false
       end
 
-      return true
+      successfully_locked
     end
 
+    # if the message was successfully procesed, lock for another lifespan length
+    # so it isn't reprocessed
     def self.complete(nonce)
-      if @server_url != nil
-        Redis.new(url: @server_url).expire(nonce, @lifespan)
+      return true if !configured?
+
+      with_redis_connection do |conn|
+        conn.expire(nonce, lifespan)
       end
-      return true
+
+      true
     end
 
+    # if it failed, unlock immediately so that retries can kick in
     def self.failed(nonce)
-      if @server_url != nil
-        Redis.new(url: @server_url).del(nonce)
+      return true if !configured?
+
+      with_redis_connection do |conn|
+        conn.del(nonce)
       end
-      return true
+
+      true
     end
 
     def self.reset
       @server_url = nil
       @timeout = nil
       @lifespan = nil
+      @pool_size = nil
+      @pool_timeout = nil
+      @configured = false
+      @redis_pool.reload(&:close)
+    end
+
+    def self.configured?
+      @configured == true
+    end
+
+    private
+
+    def self.with_redis_connection
+      if !configured?
+        raise NonceManagerNotConfiguredError, 'Unable to checkout redis connection from pool, nonce manager has not been configured. Call .configure on NonceManager.'
+      end
+
+      @redis_pool.with do |conn|
+        yield conn
+      end
     end
   end
 end

data/lib/eventq/eventq_base/queue.rb

@@ -2,6 +2,7 @@ module EventQ
   class Queue
     attr_accessor :allow_retry
     attr_accessor :allow_retry_back_off
+    attr_accessor :allow_exponential_back_off
     attr_accessor :dlq
     attr_accessor :max_retry_attempts
     attr_accessor :max_retry_delay
@@ -11,6 +12,7 @@ module EventQ
     attr_accessor :retry_delay
     attr_accessor :retry_back_off_grace
     attr_accessor :retry_back_off_weight
+    attr_accessor :retry_jitter_ratio
     # Character delimiter between namespace and queue name.  Default = '-'
     attr_accessor :namespace_delimiter
     # Flag to control that the queue runs in isolation of auto creating the topic it belongs to
@@ -20,6 +22,8 @@ module EventQ
       @allow_retry = false
       # Default retry back off settings
       @allow_retry_back_off = false
+      # Default exponential back off settings
+      @allow_exponential_back_off = false
       # Default max receive count is 30
       @max_receive_count = 30
       # Default max retry attempts is 5
@@ -34,6 +38,8 @@ module EventQ
       @retry_back_off_grace = 0
       # Multiplier for the backoff retry in case retry_delay is too small
       @retry_back_off_weight = 1
+      # Ratio of how much jitter to apply to the retry delay
+      @retry_jitter_ratio = 0
       @isolated = false
     end
   end

data/lib/eventq/eventq_rabbitmq/rabbitmq_queue_worker.rb

@@ -78,16 +78,7 @@ module EventQ
           message.retry_attempts += 1
           retry_attempts = message.retry_attempts - queue.retry_back_off_grace
           retry_attempts = 1 if retry_attempts < 1
-
-          if queue.allow_retry_back_off == true
-            message_ttl = retry_attempts * queue.retry_delay
-            if (retry_attempts * queue.retry_delay) > queue.max_retry_delay
-              EventQ.logger.debug { "[#{self.class}] - Max message back off retry delay reached." }
-              message_ttl = queue.max_retry_delay
-            end
-          else
-            message_ttl = queue.retry_delay
-          end
+          message_ttl = retry_delay(queue, retry_attempts)
 
           EventQ.logger.debug { "[#{self.class}] - Sending message for retry. Message TTL: #{message_ttl}" }
           retry_exchange.publish(serialize_message(message), :expiration => message_ttl)
@@ -128,6 +119,31 @@ module EventQ
             raise "Unrecognized status: #{status}"
         end
       end
+
+      def retry_delay(queue, retry_attempts)
+        return queue.retry_delay unless queue.allow_retry_back_off
+
+        message_ttl = if queue.allow_exponential_back_off
+          queue.retry_delay * 2 ** (retry_attempts - 1)
+        else
+          queue.retry_delay * retry_attempts
+        end
+
+        if message_ttl > queue.max_retry_delay
+          EventQ.logger.debug { "[#{self.class}] - Max message back off retry delay reached." }
+          message_ttl = queue.max_retry_delay
+        end
+
+        apply_jitter(queue.retry_jitter_ratio, message_ttl)
+      end
+
+      def apply_jitter(retry_jitter_ratio, message_ttl)
+        return message_ttl if retry_jitter_ratio == 0
+
+        ratio = retry_jitter_ratio / 100.0
+        min_message_ttl = (message_ttl * (1 - ratio)).to_i
+        rand(min_message_ttl..message_ttl)
+      end
     end
   end
 end

data/lib/eventq/queue_worker.rb

@@ -127,7 +127,7 @@ module EventQ
 
       EventQ.logger.debug("[#{self.class}] - Message received. Id: #{message.id}. Retry Attempts: #{retry_attempts}")
 
-      if (!EventQ::NonceManager.is_allowed?(message.id))
+      if (!EventQ::NonceManager.lock(message.id))
         EventQ.logger.warn("[#{self.class}] - Duplicate Message received. Id: #{message.id}. Ignoring message.")
         status = :duplicate
         return status, message_args

data/lib/eventq.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require 'securerandom'
-require 'redlock'
 require 'class_kit'
 require 'hash_kit'
 require 'oj'
@@ -22,6 +23,3 @@ require_relative 'eventq/eventq_base/nonce_manager'
 require_relative 'eventq/eventq_base/signature_providers'
 require_relative 'eventq/eventq_base/exceptions'
 require_relative 'eventq/queue_worker'
-
-
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eventq
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.2.0
 platform: ruby
 authors:
 - SageOne
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-08 00:00:00.000000000 Z
+date: 2025-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -123,33 +123,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.18.0
 - !ruby/object:Gem::Dependency
-  name: aws-sdk-sqs
+  name: aws-sdk-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-sns
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-sqs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bunny
   requirement: !ruby/object:Gem::Requirement
@@ -221,7 +235,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: redlock
+  name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -295,7 +309,7 @@ homepage: https://github.com/sage/eventq
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -310,8 +324,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: EventQ is a pub/sub system that uses async notifications and message queues
 test_files: []