sidekiq-defer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a65a0f7cbd6662bd9c552c3f5ae062297a09043c34a4616d6a811e860fc77fc5
+  data.tar.gz: 39de49a6c7e84a573f68eb01f6e3c62ca1ac0fe5edf9e9310edd124aa9afdd83
+SHA512:
+  metadata.gz: 51289603549d4c4283ed6a3768964360d409ac7753e05a9ab1651c0fb7907a0d3ee14c2511f1c693aa25584cdf5286a0555af5eb7f7a9570849e566a36640d38
+  data.tar.gz: 12f72295a1ff9bb9da191585bdf8d8c9dbe3c35e3a4770e3f8a5c0775817323443ace93bc9607b4cd4b19dd6889b8cb3aca5fbd7febb58e69460839ee500767d

data/Changes.md

@@ -0,0 +1,43 @@
+# sidekiq-defer Changes
+
+1.0.0
+---------
+
+First release under its own version line; use this instead of 9.0.0.
+
+- Jobs are named after their target in Sidekiq metrics, job logs and Sentry: the target's class
+  name is stored in the job's `wrapped` key (`wrap_target: false` turns it off).
+- Fix: 9.0.0 pushed `Foo::DeferredJob`, which was only defined in the process that called
+  `Foo.delay`, so Sidekiq servers failed with `NameError`. Jobs run through the shared
+  `Sidekiq::Defer::DelayedClass` / `DelayedModel` / `DelayedMailer` again.
+- Fix: the Web UI showed raw YAML arguments for `Sidekiq::Defer::Delayed*` jobs.
+- Fix: delayed mailer methods receive keyword arguments.
+- `legacy_class_names: true` pushes `Sidekiq::DelayExtensions::Delayed*` for rolling deploys from
+  `sidekiq-delay_extensions`.
+- `Proxy#build_item` hook for adding keys to the job hash.
+- `Sidekiq::Defer::DelayedClass` gets `jobs_for` under `Sidekiq::Testing`.
+- Requires Sidekiq >= 7.0, < 9. Packages only files committed to git. Release tasks in `rakelib/release.rake`.
+- Lint with RuboCop (single quotes) instead of StandardRB.
+- Renamed gem to `sidekiq-defer`
+- Module renamed from `Sidekiq::DelayExtensions` to `Sidekiq::Delay`
+- `Sidekiq::DelayExtensions` kept as a backward-compatible alias
+
+8.0.0
+---------
+
+- Support sidekiq v8.0+
+
+7.0.0
+---------
+
+- Support sidekiq v6.5+
+
+6.4.1
+---------
+
+- Extracted from https://github.com/mperham/sidekiq/tree/v6.4.1
+
+6.4.0
+---------
+
+- Extracted from https://github.com/mperham/sidekiq/tree/v6.4.0

data/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) Contributed Systems LLC
+
+Sidekiq is an Open Source project licensed under the terms of
+the LGPLv3 license.  Please see <http://www.gnu.org/licenses/lgpl-3.0.html>
+for license text.
+
+Sidekiq Pro and Sidekiq Enterprise have a commercial-friendly license.
+You can find the commercial license in COMM-LICENSE.txt.
+Please see https://sidekiq.org for purchasing options.

data/README.md

@@ -0,0 +1,115 @@
+sidekiq-defer
+==============
+
+[![Gem Version](https://badge.fury.io/rb/sidekiq-defer.svg)](https://rubygems.org/gems/sidekiq-defer)
+
+The Sidekiq delay extensions were removed in Sidekiq 7.x. This gem restores them for apps still relying on the `delay`/`delay_for`/`delay_until` pattern.
+
+Requirements
+-----------------
+
+- Redis: 6.2+
+- Ruby: MRI 3.2+
+- Sidekiq 7.0+ (< 9)
+
+Installation
+-----------------
+
+    gem 'sidekiq-defer', '~> 1.0'
+
+In your initializer:
+
+```ruby
+Sidekiq::Defer.enable_delay!
+```
+
+Then any class, ActiveRecord model or mailer can run a method in the background:
+
+```ruby
+Report.delay.export(account_id)
+Report.delay_for(10.minutes, queue: :low).export(account_id)
+UserMailer.delay_until(1.day.from_now).welcome(user_id)
+```
+
+Options:
+
+| Option | Default | |
+|---|---|---|
+| `limit_payload_size:` | `false` | `true` (8 KB) or a byte count: log a warning when the YAML payload is larger. |
+| `wrap_target:` | `true` | Name the job after its target in metrics, logs and error reports (see below). |
+| `legacy_class_names:` | `false` | Push jobs as `Sidekiq::DelayExtensions::Delayed*` (see upgrading). |
+
+Metrics and naming
+-----------------
+
+Every delayed call runs through one of three job classes: `Sidekiq::Defer::DelayedClass`,
+`DelayedModel` and `DelayedMailer`. The gem also stores the target's class name in the job's
+`wrapped` key, as ActiveJob does. Sidekiq reads `wrapped` first, so `Report.delay.export` is listed
+as `Report` on the Metrics page, in the job logger's `class` field, and in Sentry transaction names.
+The Web UI shows `Report.export` and the original arguments.
+
+`wrapped` is a class name, never `Report.export`: Sidekiq's retry handler resolves it with
+`const_get`. If the target is itself a Sidekiq job class, its `sidekiq_retry_in` and
+`sidekiq_retries_exhausted` blocks apply to the delayed call. To extend the job hash, prepend a
+module that overrides `Sidekiq::Defer::Proxy#build_item`, or use Sidekiq client middleware.
+
+Upgrading from `sidekiq-delay_extensions`
+-----------------
+
+`Sidekiq::DelayExtensions` and `Sidekiq::TestingDelayExtensions` are aliases of the new names,
+so existing code and jobs already in Redis keep working.
+
+New jobs are pushed as `Sidekiq::Defer::Delayed*`, which processes still running
+`sidekiq-delay_extensions` can't resolve. For a rolling deploy:
+
+1. Deploy with `Sidekiq::Defer.enable_delay!(legacy_class_names: true)`. Jobs keep the old class
+   name but already get the `wrapped` name.
+2. Once every process runs `sidekiq-defer`, remove `legacy_class_names: true`.
+
+Under `Sidekiq::Testing`, the current class names are always used, so `Sidekiq::Defer::DelayedClass.jobs` works.
+
+Upgrading from Sidekiq's built-in extensions
+-----------------
+
+Jobs already in Redis were serialized with the old class names. Add these aliases so they can still be processed:
+
+```ruby
+Sidekiq::Extensions::DelayedClass  = Sidekiq::Defer::DelayedClass
+Sidekiq::Extensions::DelayedModel  = Sidekiq::Defer::DelayedModel
+Sidekiq::Extensions::DelayedMailer = Sidekiq::Defer::DelayedMailer
+```
+
+Testing
+-----------------
+
+```ruby
+require 'sidekiq/defer/testing'
+
+Report.delay.export(1)
+Sidekiq::Defer::DelayedClass.jobs.size          # => 1
+Sidekiq::Defer::DelayedClass.jobs_for(Report)   # jobs whose target is Report
+```
+
+Releasing
+-----------------
+
+    rake "release:bump[minor]"   # bump version.rb, add a Changes.md section
+    rake release:dry_run         # checks, lint, tests, package inspection; pushes nothing
+    rake release                 # the same checks, then tag vX.Y.Z and push to rubygems.org
+
+Contributing
+-----------------
+
+Please open issues or pull requests at https://github.com/moskvin/sidekiq-delay_extensions.
+
+
+License
+-----------------
+
+Please see [LICENSE](https://github.com/moskvin/sidekiq-delay_extensions/blob/sidekiq8/LICENSE) for licensing details.
+
+
+Original Author
+-----------------
+
+Mike Perham, [@getajobmike](https://twitter.com/getajobmike) / [@sidekiq](https://twitter.com/sidekiq), [https://www.mikeperham.com](https://www.mikeperham.com) / [https://www.contribsys.com](https://www.contribsys.com)

data/lib/sidekiq/defer/action_mailer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'sidekiq/defer/generic_proxy'
+
+module Sidekiq
+  module Defer
+    ##
+    # Adds +delay+, +delay_for+ and +delay_until+ methods to ActionMailer to offload arbitrary email
+    # delivery to Sidekiq.
+    #
+    # @example
+    #    UserMailer.delay.send_welcome_email(new_user)
+    #    UserMailer.delay_for(5.days).send_welcome_email(new_user)
+    #    UserMailer.delay_until(5.days.from_now).send_welcome_email(new_user)
+    class DelayedMailer
+      include Sidekiq::Job
+
+      def perform(yml)
+        (target, method_name, args, kwargs) = YAML.safe_load(yml, permitted_classes: [Symbol])
+        msg = target.public_send(method_name, *args, **kwargs.to_h)
+        # The email method can return nil, which causes ActionMailer to return
+        # an undeliverable empty message.
+        raise "#{target.name}##{method_name} returned an undeliverable mail object" unless msg
+
+        msg.deliver_now
+      end
+    end
+
+    module ActionMailer
+      def sidekiq_delay(**)
+        Proxy.new(DelayedMailer, self, **)
+      end
+
+      def sidekiq_delay_for(interval, **)
+        Proxy.new(DelayedMailer, self, **, at: Time.now.to_f + interval.to_f)
+      end
+
+      def sidekiq_delay_until(timestamp, **)
+        Proxy.new(DelayedMailer, self, **, at: timestamp.to_f)
+      end
+
+      alias delay sidekiq_delay
+      alias delay_for sidekiq_delay_for
+      alias delay_until sidekiq_delay_until
+    end
+  end
+end

data/lib/sidekiq/defer/active_record.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'sidekiq/defer/generic_proxy'
+
+module Sidekiq
+  module Defer
+    ##
+    # Adds +delay+, +delay_for+ and +delay_until+ methods to ActiveRecord to offload instance method
+    # execution to Sidekiq.
+    #
+    # @example
+    #   User.recent_signups.each { |user| user.delay.mark_as_awesome }
+    #
+    # Please note, this is not recommended as this will serialize the entire
+    # object to Redis.  Your Sidekiq jobs should pass IDs, not entire instances.
+    # This is here for backwards compatibility with Delayed::Job only.
+    class DelayedModel
+      include Sidekiq::Job
+
+      def perform(yml)
+        (target, method_name, args, kwargs) = YAML.safe_load(yml, permitted_classes: [Symbol])
+        target.__send__(method_name, *args, **kwargs.to_h)
+      end
+    end
+
+    module ActiveRecord
+      def sidekiq_delay(**)
+        Proxy.new(DelayedModel, self, **)
+      end
+
+      def sidekiq_delay_for(interval, **)
+        Proxy.new(DelayedModel, self, **, at: Time.now.to_f + interval.to_f)
+      end
+
+      def sidekiq_delay_until(timestamp, **)
+        Proxy.new(DelayedModel, self, **, at: timestamp.to_f)
+      end
+
+      alias delay sidekiq_delay
+      alias delay_for sidekiq_delay_for
+      alias delay_until sidekiq_delay_until
+    end
+  end
+end

data/lib/sidekiq/defer/api.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'sidekiq/api'
+
+module Sidekiq
+  module Defer
+    # Current, pre-rename and Sidekiq 6 built-in names, plus 9.0.0 per-target classes.
+    DELAYED_JOB_PATTERN = /\ASidekiq::(?:Defer|DelayExtensions|Delay|Extensions)::Delayed|::DeferredJob\z/
+
+    module JobRecord
+      def display_class
+        # Unwrap known wrappers so they show up in a human-friendly manner in the Web UI
+        @display_class ||= self['display_class'] || begin
+          case klass
+          when DELAYED_JOB_PATTERN
+            safe_load(args[0], klass) do |target, method, _|
+              "#{target}.#{method}"
+            end
+          else
+            super
+          end
+        end
+      end
+
+      def display_args
+        # Unwrap known wrappers so they show up in a human-friendly manner in the Web UI
+        @display_args ||= case klass
+                          when DELAYED_JOB_PATTERN
+                            safe_load(args[0], args) do |_, _, arg, kwargs|
+                              if !kwargs || kwargs.empty?
+                                arg
+                              else
+                                [arg, kwargs]
+                              end
+                            end
+                          else
+                            super
+                          end
+      end
+
+      private
+
+      def safe_load(content, _default)
+        yield(*YAML.safe_load(content, permitted_classes: [Symbol]))
+      end
+    end
+  end
+end

data/lib/sidekiq/defer/class_methods.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'sidekiq/defer/generic_proxy'
+
+module Sidekiq
+  module Defer
+    ##
+    # Adds `delay`, `delay_for` and `delay_until` methods to all Classes to offload class method
+    # execution to Sidekiq.
+    #
+    # @example
+    #   User.delay.delete_inactive
+    #   Wikipedia.delay.download_changes_for(Date.today)
+    #
+    class DelayedClass
+      include Sidekiq::Job
+
+      def perform(yml)
+        (target, method_name, args, kwargs) = YAML.safe_load(yml, permitted_classes: [Symbol])
+        target.__send__(method_name, *args, **kwargs)
+      end
+    end
+
+    module Klass
+      def sidekiq_delay(**)
+        Proxy.new(DelayedClass, self, **)
+      end
+
+      def sidekiq_delay_for(interval, **)
+        Proxy.new(DelayedClass, self, **, at: Time.now.to_f + interval.to_f)
+      end
+
+      def sidekiq_delay_until(timestamp, **)
+        Proxy.new(DelayedClass, self, **, at: timestamp.to_f)
+      end
+
+      alias delay sidekiq_delay
+      alias delay_for sidekiq_delay_for
+      alias delay_until sidekiq_delay_until
+    end
+  end
+end
+
+Module.include Sidekiq::Defer::Klass unless defined?(Rails)

data/lib/sidekiq/defer/generic_proxy.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Sidekiq
+  module Defer
+    DEFAULT_SIZE_LIMIT = 8_192
+
+    class Proxy < BasicObject
+      def initialize(performable, target, **options)
+        @performable = performable
+        @target = target
+        @opts = options.transform_keys(&:to_s)
+      end
+
+      def respond_to_missing?(_name, _include_private = false)
+        true
+      end
+
+      def method_missing(name, *args, **kwargs)
+        # Sidekiq has a limitation in that its message must be JSON.
+        # JSON can't round trip real Ruby objects so we use YAML to
+        # serialize the objects to a String. The YAML will be converted
+        # to JSON and then deserialized on the other side back into a
+        # Ruby object.
+        obj = [@target, name, args, kwargs]
+        marshalled = ::YAML.dump(obj)
+        print_warning(name, marshalled)
+
+        @performable.client_push(build_item(name, marshalled))
+      end
+
+      # The job hash pushed to Sidekiq. Override (e.g. with prepend) to add keys.
+      def build_item(name, marshalled)
+        item = { 'class' => ::Sidekiq::Defer.job_class_name(@performable),
+                 'args' => [marshalled],
+                 'display_class' => "#{@target}.#{name}" }
+        wrapped = ::Sidekiq::Defer.wrapped_name(@target)
+        item['wrapped'] = wrapped if wrapped
+        item.merge(@opts)
+      end
+
+      def print_warning(name, dump)
+        limited_payload_size = Defer.limit_payload_size
+        return unless limited_payload_size
+
+        size = limited_payload_size == true ? DEFAULT_SIZE_LIMIT : limited_payload_size
+        return if dump.bytesize <= size
+
+        ::Sidekiq.logger.warn do
+          "#{@target}.#{name} job argument is #{dump.bytesize} bytes, you should refactor it to reduce the size"
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/defer/testing.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'sidekiq/testing'
+
+module Sidekiq
+  module TestingDefer
+    def jobs_for(klass)
+      jobs.select do |job|
+        marshalled = job['args'][0]
+        marshalled.index(klass.to_s) && YAML.safe_load(marshalled, permitted_classes: [Symbol])[0] == klass
+      end
+    end
+
+    def self.enable_delay_testing!
+      Sidekiq::Defer::DelayedClass.extend(TestingDefer) if defined?(Sidekiq::Defer::DelayedClass)
+      Sidekiq::Defer::DelayedMailer.extend(TestingDefer) if defined?(Sidekiq::Defer::DelayedMailer)
+      Sidekiq::Defer::DelayedModel.extend(TestingDefer) if defined?(Sidekiq::Defer::DelayedModel)
+    end
+  end
+
+  TestingDefer.enable_delay_testing!
+
+  TestingDelayExtensions = TestingDefer
+end

data/lib/sidekiq/defer/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Defer
+    VERSION = '1.0.0'
+  end
+end

data/lib/sidekiq/defer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+require 'sidekiq/defer/version'
+
+module Sidekiq
+  module Defer
+    # Namespace the job classes lived in before the rename. Jobs already in Redis
+    # reference it, and it resolves through the DelayExtensions alias below.
+    LEGACY_NAMESPACE = 'Sidekiq::DelayExtensions'
+
+    class << self
+      attr_accessor :limit_payload_size, :wrap_target, :legacy_class_names
+    end
+    self.wrap_target = true
+    self.legacy_class_names = false
+
+    # wrap_target: store the target's class name in the job's "wrapped" key, which
+    #   Sidekiq uses to name the job in metrics, logs and error reports.
+    # legacy_class_names: push jobs as Sidekiq::DelayExtensions::Delayed*, so processes
+    #   still running sidekiq-delay_extensions can run them during a rolling deploy.
+    def self.enable_delay!(limit_payload_size: false, wrap_target: true, legacy_class_names: false)
+      self.limit_payload_size = limit_payload_size
+      self.wrap_target = wrap_target
+      self.legacy_class_names = legacy_class_names
+      if defined?(::ActiveSupport)
+        require 'sidekiq/defer/active_record'
+        require 'sidekiq/defer/action_mailer'
+
+        # Need to patch Psych so it can autoload classes whose names are serialized
+        # in the delayed YAML.
+        Psych::Visitors::ToRuby.prepend(Sidekiq::Defer::PsychAutoload)
+
+        ActiveSupport.on_load(:active_record) do
+          include Sidekiq::Defer::ActiveRecord
+        end
+        ActiveSupport.on_load(:action_mailer) do
+          extend Sidekiq::Defer::ActionMailer
+        end
+      end
+
+      require 'sidekiq/defer/class_methods'
+      Module.include Sidekiq::Defer::Klass
+
+      require 'sidekiq/defer/api'
+      Sidekiq::JobRecord.prepend(Sidekiq::Defer::JobRecord)
+    end
+
+    # The "class" pushed for a delayed job. Legacy names are skipped under
+    # Sidekiq::Testing, which files jobs by class name.
+    def self.job_class_name(performable)
+      return performable.name unless legacy_class_names
+      return performable.name if defined?(::Sidekiq::Testing) && ::Sidekiq::Testing.enabled?
+
+      "#{LEGACY_NAMESPACE}::#{performable.name.split('::').last}"
+    end
+
+    # The "wrapped" value for a delayed job: the target's class name. It must be a
+    # constant name, because Sidekiq's retry handler resolves it with const_get.
+    def self.wrapped_name(target)
+      return unless wrap_target
+
+      (target.is_a?(::Module) ? target : target.class).name
+    end
+
+    module PsychAutoload
+      def resolve_class(klass_name)
+        return nil if !klass_name || klass_name.empty?
+
+        # constantize
+        names = klass_name.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+      rescue NameError
+        super
+      end
+    end
+  end
+
+  DelayExtensions = Defer
+end

data/lib/sidekiq/delay_extensions.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'sidekiq/defer'

data/sidekiq-defer.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lib/sidekiq/defer/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'sidekiq-defer'
+  spec.version = Sidekiq::Defer::VERSION
+  spec.authors = ['Mike Perham', 'Benjamin Fleischer', 'Nikolay Moskvin']
+  spec.email = %w[mperham@gmail.com github@benjaminfleischer.com]
+
+  spec.summary = 'Sidekiq Defer Extensions'
+  spec.description = 'Delay extensions for Sidekiq 7+'
+  spec.homepage = 'https://github.com/moskvin/sidekiq-delay_extensions'
+  spec.license = 'LGPL-3.0-or-later'
+
+  # Only files committed to git, so a local scratch file can never be published.
+  spec.files = IO.popen(%w[git ls-files -z], chdir: __dir__, &:read).split("\x0").select do |f|
+    f.start_with?('lib/') || %w[Changes.md LICENSE README.md sidekiq-defer.gemspec].include?(f)
+  end
+
+  spec.bindir = 'exe'
+  spec.executables = []
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 3.2.0'
+
+  spec.metadata = {
+    'homepage_uri' => 'https://github.com/moskvin/sidekiq-delay_extensions',
+    'bug_tracker_uri' => 'https://github.com/moskvin/sidekiq-delay_extensions/issues',
+    'changelog_uri' => 'https://github.com/moskvin/sidekiq-delay_extensions/blob/main/Changes.md',
+    'source_code_uri' => 'https://github.com/moskvin/sidekiq-delay_extensions',
+    'rubygems_mfa_required' => 'true'
+  }
+
+  spec.add_dependency 'sidekiq', '>= 7.0', '< 9'
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-defer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mike Perham
+- Benjamin Fleischer
+- Nikolay Moskvin
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+description: Delay extensions for Sidekiq 7+
+email:
+- mperham@gmail.com
+- github@benjaminfleischer.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Changes.md
+- LICENSE
+- README.md
+- lib/sidekiq/defer.rb
+- lib/sidekiq/defer/action_mailer.rb
+- lib/sidekiq/defer/active_record.rb
+- lib/sidekiq/defer/api.rb
+- lib/sidekiq/defer/class_methods.rb
+- lib/sidekiq/defer/generic_proxy.rb
+- lib/sidekiq/defer/testing.rb
+- lib/sidekiq/defer/version.rb
+- lib/sidekiq/delay_extensions.rb
+- sidekiq-defer.gemspec
+homepage: https://github.com/moskvin/sidekiq-delay_extensions
+licenses:
+- LGPL-3.0-or-later
+metadata:
+  homepage_uri: https://github.com/moskvin/sidekiq-delay_extensions
+  bug_tracker_uri: https://github.com/moskvin/sidekiq-delay_extensions/issues
+  changelog_uri: https://github.com/moskvin/sidekiq-delay_extensions/blob/main/Changes.md
+  source_code_uri: https://github.com/moskvin/sidekiq-delay_extensions
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Sidekiq Defer Extensions
+test_files: []