sidekiq-defer 9.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 77c1e553b2257d6865e6c7f26f9c8f8827df0cfb3bf1cd041ca2e08ad26b3689
+  data.tar.gz: 7ceca6114681af72c73b1622ed2d771bb361b6697295f0ce6d10171b66411493
+SHA512:
+  metadata.gz: a6a05dbce69a81702cd258c4419890d6b4767d06823b8cf16deb3e29fcb1c8e165a1dcab64e52b60175760284bc11dabb4ee9c205b7ea5a8aa2c472ef87f3d6a
+  data.tar.gz: 5afe1917ed9947930f5398617fbc5a3340cd85f47dc8c4c6ba3f5e9318f83112685a78ad4290791c6c0ea005b6cce7ee76487d1af78d50f57ad833b895cb1f3c

data/Changes.md

@@ -0,0 +1,28 @@
+# sidekiq-defer Changes
+
+9.0.0
+---------
+
+- 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/Gemfile

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "activerecord-jdbcsqlite3-adapter", platforms: :jruby
+gem "rails", "< 9"
+gem "rake"
+gem "redis-namespace"
+gem "sqlite3", platforms: :ruby
+
+# mail dependencies
+gem "net-smtp", platforms: :mri, require: false
+
+group :test do
+  gem "codecov", require: false
+  gem "minitest"
+  gem "simplecov"
+end
+
+group :development, :test do
+  gem "rubocop", require: false
+  gem "rubocop-minitest", require: false
+  gem "rubocop-rails", require: false
+  gem "rubocop-rake", require: false
+  gem "standard", ">= 1.35.1", require: false
+end
+
+group :load_test do
+  gem "hiredis"
+  gem "toxiproxy"
+end

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,74 @@
+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.
+
+Each target class gets its own namespaced worker (e.g. `MyModel::DeferredJob`, `UserMailer::DeferredJob`), so jobs appear clearly in Sidekiq metrics instead of a generic wrapper class name.
+
+Requirements
+-----------------
+
+- Redis: 6.2+
+- Ruby: MRI 3.2+
+- Sidekiq 7.0+
+
+Installation
+-----------------
+
+    gem 'sidekiq-defer'
+
+In your initializer:
+
+```ruby
+Sidekiq::Delay.enable_delay!
+```
+
+Pass `limit_payload_size: true` (or a byte count) to log warnings on large YAML payloads:
+
+```ruby
+Sidekiq::Delay.enable_delay!(limit_payload_size: 8_192)
+```
+
+Upgrading from Sidekiq's built-in extensions (IMPORTANT)
+-----------------
+
+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
+```
+
+Upgrading from `sidekiq-delay_extensions`
+-----------------
+
+`Sidekiq::DelayExtensions` and `Sidekiq::Delay` are aliased to `Sidekiq::Defer` — existing code continues to work without changes.
+
+Testing
+-----------------
+
+```ruby
+require 'sidekiq/defer/testing'
+```
+
+This hooks `DelayedMailer` and `DelayedModel` into Sidekiq's fake/inline testing modes.
+
+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/bin/scan-usages

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+# Scan a project directory for all sidekiq-delay_extensions usages.
+# Usage: bin/scan-usages [PATH]   (defaults to current directory)
+
+set -euo pipefail
+
+TARGET="${1:-.}"
+
+RUBY_GLOB=("--include=*.rb" "--include=*.gemspec" "--include=Gemfile" "--include=Gemfile.lock")
+
+echo "==> Scanning: $TARGET"
+echo ""
+
+section() { echo "--- $1 ---"; }
+
+# ── Gemfile / gemspec references ───────────────────────────────────────────
+section "Gem dependency references (Gemfile / gemspec)"
+grep -rn "sidekiq-delay_extensions\|sidekiq-delay[^/]" \
+  --include="*.rb" --include="*.gemspec" --include="Gemfile" --include="Gemfile.lock" \
+  "$TARGET" 2>/dev/null || echo "(none found)"
+echo ""
+
+# ── enable_delay! call sites ────────────────────────────────────────────────
+section "enable_delay! initializer calls"
+grep -rn "enable_delay!" "${RUBY_GLOB[@]}" "$TARGET" 2>/dev/null || echo "(none found)"
+echo ""
+
+# ── require paths ───────────────────────────────────────────────────────────
+section "require 'sidekiq/delay_extensions' paths"
+grep -rn "sidekiq/delay_extensions" "${RUBY_GLOB[@]}" "$TARGET" 2>/dev/null || echo "(none found)"
+echo ""
+
+# ── Proxy prepends / subclasses ─────────────────────────────────────────────
+section "Proxy customisations (prepend / subclass)"
+grep -rn "DelayExtensions::Proxy\|Delay::Proxy" "${RUBY_GLOB[@]}" "$TARGET" 2>/dev/null || echo "(none found)"
+echo ""
+
+# ── All remaining DelayExtensions references ────────────────────────────────
+section "All other DelayExtensions references"
+grep -rn "DelayExtensions" "${RUBY_GLOB[@]}" "$TARGET" 2>/dev/null \
+  | grep -v "enable_delay!\|delay_extensions\|DelayExtensions::Proxy" \
+  || echo "(none found)"
+echo ""
+
+# ── Summary ─────────────────────────────────────────────────────────────────
+section "Summary: unique files"
+grep -rl "DelayExtensions\|sidekiq.delay_extensions\|sidekiq/delay_extensions" \
+  "${RUBY_GLOB[@]}" "$TARGET" 2>/dev/null \
+  | grep -v "vendor/\|node_modules/" \
+  | sort \
+  | uniq \
+  | while read -r f; do
+      count=$(grep -c "DelayExtensions\|sidekiq.delay_extensions\|sidekiq/delay_extensions" "$f" 2>/dev/null || true)
+      printf "  %-60s %s hit(s)\n" "$f" "$count"
+    done
+echo ""

data/lib/sidekiq/defer/action_mailer.rb

@@ -0,0 +1,54 @@
+# 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) = YAML.safe_load(yml, permitted_classes: [Symbol])
+        msg = target.public_send(method_name, *args)
+        # 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(**options)
+        Proxy.new(_sidekiq_delayed_job_class, self, **options)
+      end
+
+      def sidekiq_delay_for(interval, **options)
+        Proxy.new(_sidekiq_delayed_job_class, self, **options.merge(at: Time.now.to_f + interval.to_f))
+      end
+
+      def sidekiq_delay_until(timestamp, **options)
+        Proxy.new(_sidekiq_delayed_job_class, self, **options.merge(at: timestamp.to_f))
+      end
+
+      alias delay sidekiq_delay
+      alias delay_for sidekiq_delay_for
+      alias delay_until sidekiq_delay_until
+
+      private
+
+      def _sidekiq_delayed_job_class
+        const_set(:DeferredJob, Class.new(DelayedMailer)) unless const_defined?(:DeferredJob, false)
+        const_get(:DeferredJob, false)
+      end
+    end
+  end
+end

data/lib/sidekiq/defer/active_record.rb

@@ -0,0 +1,55 @@
+# 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 self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def _sidekiq_delayed_job_class
+          const_set(:DeferredJob, Class.new(DelayedModel)) unless const_defined?(:DeferredJob, false)
+          const_get(:DeferredJob, false)
+        end
+      end
+
+      def sidekiq_delay(**options)
+        Proxy.new(self.class._sidekiq_delayed_job_class, self, **options)
+      end
+
+      def sidekiq_delay_for(interval, **options)
+        Proxy.new(self.class._sidekiq_delayed_job_class, self, **options.merge(at: Time.now.to_f + interval.to_f))
+      end
+
+      def sidekiq_delay_until(timestamp, **options)
+        Proxy.new(self.class._sidekiq_delayed_job_class, self, **options.merge(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,47 @@
+# frozen_string_literal: true
+
+require 'sidekiq/api'
+
+module Sidekiq
+  module Defer
+    DELAYED_JOB_PATTERN = /\ASidekiq::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,51 @@
+# 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(**options)
+        Proxy.new(_sidekiq_delayed_job_class, self, **options)
+      end
+
+      def sidekiq_delay_for(interval, **options)
+        Proxy.new(_sidekiq_delayed_job_class, self, **options.merge(at: Time.now.to_f + interval.to_f))
+      end
+
+      def sidekiq_delay_until(timestamp, **options)
+        Proxy.new(_sidekiq_delayed_job_class, self, **options.merge(at: timestamp.to_f))
+      end
+
+      alias_method :delay, :sidekiq_delay
+      alias_method :delay_for, :sidekiq_delay_for
+      alias_method :delay_until, :sidekiq_delay_until
+
+      private
+
+      def _sidekiq_delayed_job_class
+        const_set(:DeferredJob, Class.new(DelayedClass)) unless const_defined?(:DeferredJob, false)
+        const_get(:DeferredJob, false)
+      end
+    end
+  end
+end
+
+Module.include Sidekiq::Defer::Klass unless defined?(::Rails)

data/lib/sidekiq/defer/generic_proxy.rb

@@ -0,0 +1,48 @@
+# 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?
+        true
+      end
+
+      def method_missing(name, *, **)
+        # 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, [*], {**}]
+        marshalled = ::YAML.dump(obj)
+        print_warning(name, marshalled)
+
+        @performable.client_push({"class" => @performable,
+                                  "args" => [marshalled],
+                                  "display_class" => "#{@target}.#{name}"}.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) ? limited_payload_size : DEFAULT_SIZE_LIMIT
+        return if dump.size <= 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,25 @@
+# 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::DelayedMailer.extend(TestingDefer) if defined?(Sidekiq::Defer::DelayedMailer)
+      return unless defined?(Sidekiq::Defer::DelayedModel)
+
+      Sidekiq::Defer::DelayedModel.extend(TestingDefer)
+    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 = '9.0.0'
+  end
+end

data/lib/sidekiq/defer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+
+module Sidekiq
+  module Defer
+    class << self; attr_accessor :limit_payload_size; end
+
+    def self.enable_delay!(limit_payload_size: false)
+      self.limit_payload_size = limit_payload_size
+      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
+
+    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,37 @@
+# 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']
+  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'
+
+  spec.files = Dir.glob('{bin,lib,config}/**/*') + %w[
+    Changes.md
+    Gemfile
+    LICENSE
+    README.md
+    sidekiq-defer.gemspec
+  ]
+
+  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/sidekiq8/Changes.md',
+    'source_code_uri' => 'https://github.com/moskvin/sidekiq-delay_extensions'
+  }
+
+  spec.add_dependency 'sidekiq', '< 9'
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-defer
+version: !ruby/object:Gem::Version
+  version: 9.0.0
+platform: ruby
+authors:
+- Mike Perham
+- Benjamin Fleischer
+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: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !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
+- Gemfile
+- LICENSE
+- README.md
+- bin/scan-usages
+- 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/sidekiq8/Changes.md
+  source_code_uri: https://github.com/moskvin/sidekiq-delay_extensions
+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: 3.6.9
+specification_version: 4
+summary: Sidekiq Defer Extensions
+test_files: []