sidekiq-batch 0.1.5 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2d61afa130ecc7d339ec1ff9c2b38ce8870ef0e5
-  data.tar.gz: a28ac95c3bb93ebd274f99b253e8f7db7d01ffeb
+SHA256:
+  metadata.gz: 56a9cb0fe2d48eba0959e20ad98e52e62e326bb71168f13f4c48e0ad33079447
+  data.tar.gz: ae145f7d0381f9a83ec2f0ba93be5a290589b1cd77e7544fc20b4f15fc823d0e
 SHA512:
-  metadata.gz: 3ad9d8f6485798ebe314bd561f040b44742bf892d89d044793c77b3eadb9b548c81dfa5884ca35b89eab044159354d5a46fc9ff99864e0df1b9660c69b16d6dc
-  data.tar.gz: dc66cae976602555b91ce985d6bdc7bf1c5fc3fb9491cc5f14a2debded4799951b1c7eafe7af9940b9986e25d76192969b7140ba58dd647b28a46482627e32f4
+  metadata.gz: 45aee8ac26397847e5738ebf21b34a7505cd367d64596b9e72ff1c51993c622e53850999cb9bcae4fa2152c7e0471c65d3c824af3af06cdefecee199b4f7c8a5
+  data.tar.gz: 294c3bb0b9f908ee2aabf6dd62adcb296ff6409a148b3db77a456f50c728f369583bf15af4d2aa034947fb5175741985549c70d5328acb8ff471332689ad27c7

data/.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "04:00"
+  open-pull-requests-limit: 10

data/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["2.5", "2.6", "2.7", "3.0", "3.1", ruby-head]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        bundler-cache: true # 'bundle install' and cache gems
+        ruby-version: ${{ matrix.ruby }}
+    - name: Run tests
+      run: bundle exec rake

data/.github/workflows/stale.yml

@@ -0,0 +1,19 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: "0 0 * * *"
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/stale@v1
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'Stale issue message'
+        stale-pr-message: 'Stale pull request message'
+        stale-issue-label: 'no-issue-activity'
+        stale-pr-label: 'no-pr-activity'

data/Gemfile

@@ -5,5 +5,4 @@ gemspec
 group :test do
   gem "simplecov"
   gem "codeclimate-test-reporter", "~> 1.0.0"
-  gem 'pry-byebug'
 end

data/lib/sidekiq/batch/callback.rb

@@ -6,66 +6,98 @@ module Sidekiq
 
         def perform(clazz, event, opts, bid, parent_bid)
           return unless %w(success complete).include?(event)
-          clazz, method = clazz.split("#") if (clazz.class == String && clazz.include?("#"))
+          clazz, method = clazz.split("#") if (clazz && clazz.class == String && clazz.include?("#"))
           method = "on_#{event}" if method.nil?
           status = Sidekiq::Batch::Status.new(bid)
 
-          if object = Object.const_get(clazz)
+          if clazz && object = Object.const_get(clazz)
             instance = object.new
             instance.send(method, status, opts) if instance.respond_to?(method)
           end
-
-          send(event.to_sym, bid, status, parent_bid)
         end
+      end
 
+      class Finalize
+        def dispatch status, opts
+          bid = opts["bid"]
+          callback_bid = status.bid
+          event = opts["event"].to_sym
+          callback_batch = bid != callback_bid
 
-        def success(bid, status, parent_bid)
-          if (parent_bid)
-            _, _, success, pending, children = Sidekiq.redis do |r|
-              r.multi do
-                r.sadd("BID-#{parent_bid}-success", bid)
-                r.expire("BID-#{parent_bid}-success", Sidekiq::Batch::BID_EXPIRE_TTL)
-                r.scard("BID-#{parent_bid}-success")
-                r.hincrby("BID-#{parent_bid}", "pending", 0)
-                r.hincrby("BID-#{parent_bid}", "children", 0)
-              end
-            end
+          Sidekiq.logger.debug {"Finalize #{event} batch id: #{opts["bid"]}, callback batch id: #{callback_bid} callback_batch #{callback_batch}"}
 
-            Batch.enqueue_callbacks(:success, parent_bid) if pending.to_i.zero? && children == success
-          end
+          batch_status = Status.new bid
+          send(event, bid, batch_status, batch_status.parent_bid)
 
-          Sidekiq.redis do |r|
-            r.del "BID-#{bid}-success", "BID-#{bid}-complete", "BID-#{bid}-jids", "BID-#{bid}-failed"
-          end
+
+          # Different events are run in different callback batches
+          Sidekiq::Batch.cleanup_redis callback_bid if callback_batch
+          Sidekiq::Batch.cleanup_redis bid if event == :success
         end
 
-        def complete(bid, status, parent_bid)
-          if (parent_bid)
-            _, complete, pending, children, failure = Sidekiq.redis do |r|
-              r.multi do
-                r.sadd("BID-#{parent_bid}-complete", bid)
-                r.scard("BID-#{parent_bid}-complete")
-                r.hincrby("BID-#{parent_bid}", "pending", 0)
-                r.hincrby("BID-#{parent_bid}", "children", 0)
-                r.hlen("BID-#{parent_bid}-failed")
-              end
-            end
+        def success(bid, status, parent_bid)
+          return unless parent_bid
 
-            Batch.enqueue_callbacks(:complete, parent_bid) if complete == children && pending == failure
+          _, _, success, _, complete, pending, children, failure = Sidekiq.redis do |r|
+            r.multi do |pipeline|
+              pipeline.sadd("BID-#{parent_bid}-success", bid)
+              pipeline.expire("BID-#{parent_bid}-success", Sidekiq::Batch::BID_EXPIRE_TTL)
+              pipeline.scard("BID-#{parent_bid}-success")
+              pipeline.sadd("BID-#{parent_bid}-complete", bid)
+              pipeline.scard("BID-#{parent_bid}-complete")
+              pipeline.hincrby("BID-#{parent_bid}", "pending", 0)
+              pipeline.hincrby("BID-#{parent_bid}", "children", 0)
+              pipeline.scard("BID-#{parent_bid}-failed")
+            end
+          end
+          # if job finished successfully and parent batch completed call parent complete callback
+          # Success callback is called after complete callback
+          if complete == children && pending == failure
+            Sidekiq.logger.debug {"Finalize parent complete bid: #{parent_bid}"}
+            Batch.enqueue_callbacks(:complete, parent_bid)
           end
 
+        end
+
+        def complete(bid, status, parent_bid)
           pending, children, success = Sidekiq.redis do |r|
-            r.multi do
-              r.hincrby("BID-#{bid}", "pending", 0)
-              r.hincrby("BID-#{bid}", "children", 0)
-              r.scard("BID-#{bid}-success")
+            r.multi do |pipeline|
+              pipeline.hincrby("BID-#{bid}", "pending", 0)
+              pipeline.hincrby("BID-#{bid}", "children", 0)
+              pipeline.scard("BID-#{bid}-success")
             end
           end
 
-          Batch.enqueue_callbacks(:success, bid) if pending.to_i.zero? && children == success
+          # if we batch was successful run success callback
+          if pending.to_i.zero? && children == success
+            Batch.enqueue_callbacks(:success, bid)
+
+          elsif parent_bid
+            # if batch was not successfull check and see if its parent is complete
+            # if the parent is complete we trigger the complete callback
+            # We don't want to run this if the batch was successfull because the success
+            # callback may add more jobs to the parent batch
 
+            Sidekiq.logger.debug {"Finalize parent complete bid: #{parent_bid}"}
+            _, complete, pending, children, failure = Sidekiq.redis do |r|
+              r.multi do |pipeline|
+                pipeline.sadd("BID-#{parent_bid}-complete", bid)
+                pipeline.scard("BID-#{parent_bid}-complete")
+                pipeline.hincrby("BID-#{parent_bid}", "pending", 0)
+                pipeline.hincrby("BID-#{parent_bid}", "children", 0)
+                pipeline.scard("BID-#{parent_bid}-failed")
+              end
+            end
+            if complete == children && pending == failure
+              Batch.enqueue_callbacks(:complete, parent_bid)
+            end
+          end
         end
 
+        def cleanup_redis bid, callback_bid=nil
+          Sidekiq::Batch.cleanup_redis bid
+          Sidekiq::Batch.cleanup_redis callback_bid if callback_bid
+        end
       end
     end
   end

data/lib/sidekiq/batch/extension/worker.rb

@@ -1,11 +1,11 @@
 module Sidekiq::Batch::Extension
   module Worker
     def bid
-      Thread.current[:bid]
+      Thread.current[:batch].bid
     end
 
     def batch
-      Sidekiq::Batch.new(Thread.current[:bid].bid) if Thread.current[:bid]
+      Thread.current[:batch]
     end
 
     def valid_within_batch?

data/lib/sidekiq/batch/middleware.rb

@@ -5,7 +5,7 @@ module Sidekiq
     module Middleware
       class ClientMiddleware
         def call(_worker, msg, _queue, _redis_pool = nil)
-          if (batch = Thread.current[:bid])
+          if (batch = Thread.current[:batch])
             batch.increment_job_queue(msg['jid']) if (msg[:bid] = batch.bid)
           end
           yield
@@ -16,15 +16,15 @@ module Sidekiq
         def call(_worker, msg, _queue)
           if (bid = msg['bid'])
             begin
-              Thread.current[:bid] = Sidekiq::Batch.new(bid)
+              Thread.current[:batch] = Sidekiq::Batch.new(bid)
               yield
-              Thread.current[:bid] = nil
+              Thread.current[:batch] = nil
               Batch.process_successful_job(bid, msg['jid'])
             rescue
               Batch.process_failed_job(bid, msg['jid'])
               raise
             ensure
-              Thread.current[:bid] = nil
+              Thread.current[:batch] = nil
             end
           else
             yield

data/lib/sidekiq/batch/status.rb

@@ -45,13 +45,15 @@ module Sidekiq
 
       def data
         {
+          bid: bid,
           total: total,
           failures: failures,
           pending: pending,
           created_at: created_at,
           complete: complete?,
           failure_info: failure_info,
-          parent_bid: parent_bid
+          parent_bid: parent_bid,
+          child_count: child_count
         }
       end
     end

data/lib/sidekiq/batch/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
   class Batch
-    VERSION = '0.1.5'.freeze
+    VERSION = '0.1.8'.freeze
   end
 end

data/lib/sidekiq/batch.rb

@@ -33,16 +33,21 @@ module Sidekiq
       persist_bid_attr('callback_queue', callback_queue)
     end
 
+    def callback_batch=(callback_batch)
+      @callback_batch = callback_batch
+      persist_bid_attr('callback_batch', callback_batch)
+    end
+
     def on(event, callback, options = {})
       return unless %w(success complete).include?(event.to_s)
       callback_key = "#{@bidkey}-callbacks-#{event}"
       Sidekiq.redis do |r|
-        r.multi do
-          r.sadd(callback_key, JSON.unparse({
+        r.multi do |pipeline|
+          pipeline.sadd(callback_key, JSON.unparse({
             callback: callback,
             opts: options
           }))
-          r.expire(callback_key, BID_EXPIRE_TTL)
+          pipeline.expire(callback_key, BID_EXPIRE_TTL)
         end
       end
     end
@@ -54,13 +59,13 @@ module Sidekiq
 
       begin
         if !@existing && !@initialized
-          parent_bid = Thread.current[:bid].bid if Thread.current[:bid]
+          parent_bid = Thread.current[:batch].bid if Thread.current[:batch]
 
           Sidekiq.redis do |r|
-            r.multi do
-              r.hset(@bidkey, "created_at", @created_at)
-              r.hset(@bidkey, "parent_bid", parent_bid.to_s) if parent_bid
-              r.expire(@bidkey, BID_EXPIRE_TTL)
+            r.multi do |pipeline|
+              pipeline.hset(@bidkey, "created_at", @created_at)
+              pipeline.hset(@bidkey, "parent_bid", parent_bid.to_s) if parent_bid
+              pipeline.expire(@bidkey, BID_EXPIRE_TTL)
             end
           end
 
@@ -70,28 +75,29 @@ module Sidekiq
         @ready_to_queue = []
 
         begin
-          parent = Thread.current[:bid]
-          Thread.current[:bid] = self
+          parent = Thread.current[:batch]
+          Thread.current[:batch] = self
           yield
         ensure
-          Thread.current[:bid] = parent
+          Thread.current[:batch] = parent
         end
 
         return [] if @ready_to_queue.size == 0
 
         Sidekiq.redis do |r|
-          r.multi do
+          r.multi do |pipeline|
             if parent_bid
-              r.hincrby("BID-#{parent_bid}", "children", 1)
-              r.expire("BID-#{parent_bid}", BID_EXPIRE_TTL)
+              pipeline.hincrby("BID-#{parent_bid}", "children", 1)
+              pipeline.hincrby("BID-#{parent_bid}", "total", @ready_to_queue.size)
+              pipeline.expire("BID-#{parent_bid}", BID_EXPIRE_TTL)
             end
 
-            r.hincrby(@bidkey, "pending", @ready_to_queue.size)
-            r.hincrby(@bidkey, "total", @ready_to_queue.size)
-            r.expire(@bidkey, BID_EXPIRE_TTL)
+            pipeline.hincrby(@bidkey, "pending", @ready_to_queue.size)
+            pipeline.hincrby(@bidkey, "total", @ready_to_queue.size)
+            pipeline.expire(@bidkey, BID_EXPIRE_TTL)
 
-            r.sadd(@bidkey + "-jids", @ready_to_queue)
-            r.expire(@bidkey + "-jids", BID_EXPIRE_TTL)
+            pipeline.sadd(@bidkey + "-jids", @ready_to_queue)
+            pipeline.expire(@bidkey + "-jids", BID_EXPIRE_TTL)
           end
         end
 
@@ -132,91 +138,155 @@ module Sidekiq
 
     def persist_bid_attr(attribute, value)
       Sidekiq.redis do |r|
-        r.multi do
-          r.hset(@bidkey, attribute, value)
-          r.expire(@bidkey, BID_EXPIRE_TTL)
+        r.multi do |pipeline|
+          pipeline.hset(@bidkey, attribute, value)
+          pipeline.expire(@bidkey, BID_EXPIRE_TTL)
         end
       end
     end
 
     class << self
       def process_failed_job(bid, jid)
-        _, pending, failed, children, complete = Sidekiq.redis do |r|
-          r.multi do
-            r.sadd("BID-#{bid}-failed", jid)
+        _, pending, failed, children, complete, parent_bid = Sidekiq.redis do |r|
+          r.multi do |pipeline|
+            pipeline.sadd("BID-#{bid}-failed", jid)
 
-            r.hincrby("BID-#{bid}", "pending", 0)
-            r.scard("BID-#{bid}-failed")
-            r.hincrby("BID-#{bid}", "children", 0)
-            r.scard("BID-#{bid}-complete")
+            pipeline.hincrby("BID-#{bid}", "pending", 0)
+            pipeline.scard("BID-#{bid}-failed")
+            pipeline.hincrby("BID-#{bid}", "children", 0)
+            pipeline.scard("BID-#{bid}-complete")
+            pipeline.hget("BID-#{bid}", "parent_bid")
 
-            r.expire("BID-#{bid}-failed", BID_EXPIRE_TTL)
+            pipeline.expire("BID-#{bid}-failed", BID_EXPIRE_TTL)
+          end
+        end
+
+        # if the batch failed, and has a parent, update the parent to show one pending and failed job
+        if parent_bid
+          Sidekiq.redis do |r|
+            r.multi do |pipeline|
+              pipeline.hincrby("BID-#{parent_bid}", "pending", 1)
+              pipeline.sadd("BID-#{parent_bid}-failed", jid)
+              pipeline.expire("BID-#{parent_bid}-failed", BID_EXPIRE_TTL)
+            end
           end
         end
 
-        enqueue_callbacks(:complete, bid) if pending.to_i == failed.to_i && children == complete
+        if pending.to_i == failed.to_i && children == complete
+          enqueue_callbacks(:complete, bid)
+        end
       end
 
       def process_successful_job(bid, jid)
         failed, pending, children, complete, success, total, parent_bid = Sidekiq.redis do |r|
-          r.multi do
-            r.scard("BID-#{bid}-failed")
-            r.hincrby("BID-#{bid}", "pending", -1)
-            r.hincrby("BID-#{bid}", "children", 0)
-            r.scard("BID-#{bid}-complete")
-            r.scard("BID-#{bid}-success")
-            r.hget("BID-#{bid}", "total")
-            r.hget("BID-#{bid}", "parent_bid")
-
-            r.srem("BID-#{bid}-failed", jid)
-            r.srem("BID-#{bid}-jids", jid)
-            r.expire("BID-#{bid}", BID_EXPIRE_TTL)
+          r.multi do |pipeline|
+            pipeline.scard("BID-#{bid}-failed")
+            pipeline.hincrby("BID-#{bid}", "pending", -1)
+            pipeline.hincrby("BID-#{bid}", "children", 0)
+            pipeline.scard("BID-#{bid}-complete")
+            pipeline.scard("BID-#{bid}-success")
+            pipeline.hget("BID-#{bid}", "total")
+            pipeline.hget("BID-#{bid}", "parent_bid")
+
+            pipeline.srem("BID-#{bid}-failed", jid)
+            pipeline.srem("BID-#{bid}-jids", jid)
+            pipeline.expire("BID-#{bid}", BID_EXPIRE_TTL)
           end
         end
 
-        Sidekiq.logger.info "done: #{jid} in batch #{bid}"
-
-        enqueue_callbacks(:complete, bid) if pending.to_i == failed.to_i && children == complete
-        enqueue_callbacks(:success, bid) if pending.to_i.zero? && children == success
+        all_success = pending.to_i.zero? && children == success
+        # if complete or successfull call complete callback (the complete callback may then call successful)
+        if (pending.to_i == failed.to_i && children == complete) || all_success
+          enqueue_callbacks(:complete, bid)
+          enqueue_callbacks(:success, bid) if all_success
+        end
       end
 
       def enqueue_callbacks(event, bid)
+        event_name = event.to_s
         batch_key = "BID-#{bid}"
-        callback_key = "#{batch_key}-callbacks-#{event}"
-        needed, _, callbacks, queue, parent_bid = Sidekiq.redis do |r|
-          r.multi do
-            r.hget(batch_key, event)
-            r.hset(batch_key, event, true)
-            r.smembers(callback_key)
-            r.hget(batch_key, "callback_queue")
-            r.hget(batch_key, "parent_bid")
+        callback_key = "#{batch_key}-callbacks-#{event_name}"
+        already_processed, _, callbacks, queue, parent_bid, callback_batch = Sidekiq.redis do |r|
+          r.multi do |pipeline|
+            pipeline.hget(batch_key, event_name)
+            pipeline.hset(batch_key, event_name, true)
+            pipeline.smembers(callback_key)
+            pipeline.hget(batch_key, "callback_queue")
+            pipeline.hget(batch_key, "parent_bid")
+            pipeline.hget(batch_key, "callback_batch")
           end
         end
-        return if needed == 'true'
 
-        begin
-          parent_bid = !parent_bid || parent_bid.empty? ? nil : parent_bid    # Basically parent_bid.blank?
-          Sidekiq::Client.push_bulk(
-            'class' => Sidekiq::Batch::Callback::Worker,
-            'args' => callbacks.reduce([]) do |memo, jcb|
-              cb = Sidekiq.load_json(jcb)
-              memo << [cb['callback'], event, cb['opts'], bid, parent_bid]
-            end,
-            'queue' => queue ||= 'default'
-          ) unless callbacks.empty?
-        ensure
-          cleanup_redis(bid) if event == :success
+        return if already_processed == 'true'
+
+        queue ||= "default"
+        parent_bid = !parent_bid || parent_bid.empty? ? nil : parent_bid    # Basically parent_bid.blank?
+        callback_args = callbacks.reduce([]) do |memo, jcb|
+          cb = Sidekiq.load_json(jcb)
+          memo << [cb['callback'], event_name, cb['opts'], bid, parent_bid]
+        end
+
+        opts = {"bid" => bid, "event" => event_name}
+
+        # Run callback batch finalize synchronously
+        if callback_batch
+          # Extract opts from cb_args or use current
+          # Pass in stored event as callback finalize is processed on complete event
+          cb_opts = callback_args.first&.at(2) || opts
+
+          Sidekiq.logger.debug {"Run callback batch bid: #{bid} event: #{event_name} args: #{callback_args.inspect}"}
+          # Finalize now
+          finalizer = Sidekiq::Batch::Callback::Finalize.new
+          status = Status.new bid
+          finalizer.dispatch(status, cb_opts)
+
+          return
+        end
+
+        Sidekiq.logger.debug {"Enqueue callback bid: #{bid} event: #{event_name} args: #{callback_args.inspect}"}
+
+        if callback_args.empty?
+          # Finalize now
+          finalizer = Sidekiq::Batch::Callback::Finalize.new
+          status = Status.new bid
+          finalizer.dispatch(status, opts)
+        else
+          # Otherwise finalize in sub batch complete callback
+          cb_batch = self.new
+          cb_batch.callback_batch = true
+          Sidekiq.logger.debug {"Adding callback batch: #{cb_batch.bid} for batch: #{bid}"}
+          cb_batch.on(:complete, "Sidekiq::Batch::Callback::Finalize#dispatch", opts)
+          cb_batch.jobs do
+            push_callbacks callback_args, queue
+          end
         end
       end
 
       def cleanup_redis(bid)
+        Sidekiq.logger.debug {"Cleaning redis of batch #{bid}"}
         Sidekiq.redis do |r|
-          r.del("BID-#{bid}",
-                "BID-#{bid}-callbacks-complete",
-                "BID-#{bid}-callbacks-success",
-                "BID-#{bid}-failed")
+          r.del(
+            "BID-#{bid}",
+            "BID-#{bid}-callbacks-complete",
+            "BID-#{bid}-callbacks-success",
+            "BID-#{bid}-failed",
+
+            "BID-#{bid}-success",
+            "BID-#{bid}-complete",
+            "BID-#{bid}-jids",
+          )
         end
       end
+
+    private
+
+      def push_callbacks args, queue
+        Sidekiq::Client.push_bulk(
+          'class' => Sidekiq::Batch::Callback::Worker,
+          'args' => args,
+          'queue' => queue
+        ) unless args.empty?
+      end
     end
   end
 end

data/sidekiq-batch.gemspec

@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "sidekiq", ">= 3"
 
-  spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "fakeredis", "~> 0.7.0"
+  spec.add_development_dependency "fakeredis", "~> 0.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-batch
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.8
 platform: ruby
 authors:
 - Marcin Naglik
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-10-16 00:00:00.000000000 Z
+date: 2022-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.0
 description: Sidekiq Batch Jobs Implementation
 email:
 - marcin.naglik@gmail.com
@@ -87,6 +87,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
+- ".github/workflows/ci.yml"
+- ".github/workflows/stale.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -106,7 +109,7 @@ homepage: http://github.com/breamware/sidekiq-batch
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -121,9 +124,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Sidekiq Batch Jobs
 test_files: []