activejob-uniqueness 0.1.2 → 0.4.0

data/lib/active_job/uniqueness/log_subscriber.rb

@@ -3,99 +3,100 @@
 require 'active_support/log_subscriber'
 
 module ActiveJob
-  class LogSubscriber < ActiveSupport::LogSubscriber #:nodoc:
-    def lock(event)
-      job = event.payload[:job]
-      resource = event.payload[:resource]
-
-      debug do
-        "Locked #{lock_info(job, resource)}" + args_info(job)
+  module Uniqueness
+    class LogSubscriber < ActiveSupport::LogSubscriber # :nodoc:
+      def lock(event)
+        job = event.payload[:job]
+        resource = event.payload[:resource]
+
+        debug do
+          "Locked #{lock_info(job, resource)}" + args_info(job)
+        end
       end
-    end
 
-    def runtime_lock(event)
-      job = event.payload[:job]
-      resource = event.payload[:resource]
+      def runtime_lock(event)
+        job = event.payload[:job]
+        resource = event.payload[:resource]
 
-      debug do
-        "Locked runtime #{lock_info(job, resource)}" + args_info(job)
+        debug do
+          "Locked runtime #{lock_info(job, resource)}" + args_info(job)
+        end
       end
-    end
 
-    def unlock(event)
-      job = event.payload[:job]
-      resource = event.payload[:resource]
+      def unlock(event)
+        job = event.payload[:job]
+        resource = event.payload[:resource]
 
-      debug do
-        "Unlocked #{lock_info(job, resource)}"
+        debug do
+          "Unlocked #{lock_info(job, resource)}"
+        end
       end
-    end
 
-    def runtime_unlock(event)
-      job = event.payload[:job]
-      resource = event.payload[:resource]
+      def runtime_unlock(event)
+        job = event.payload[:job]
+        resource = event.payload[:resource]
 
-      debug do
-        "Unlocked runtime #{lock_info(job, resource)}"
+        debug do
+          "Unlocked runtime #{lock_info(job, resource)}"
+        end
       end
-    end
 
-    def conflict(event)
-      job = event.payload[:job]
-      resource = event.payload[:resource]
+      def conflict(event)
+        job = event.payload[:job]
+        resource = event.payload[:resource]
 
-      info do
-        "Not unique #{lock_info(job, resource)}" + args_info(job)
+        info do
+          "Not unique #{lock_info(job, resource)}" + args_info(job)
+        end
       end
-    end
 
-    def runtime_conflict(event)
-      job = event.payload[:job]
-      resource = event.payload[:resource]
+      def runtime_conflict(event)
+        job = event.payload[:job]
+        resource = event.payload[:resource]
 
-      info do
-        "Not unique runtime #{lock_info(job, resource)}" + args_info(job)
+        info do
+          "Not unique runtime #{lock_info(job, resource)}" + args_info(job)
+        end
       end
-    end
 
-    private
+      private
 
-    def lock_info(job, resource)
-      "#{job.class.name} (Job ID: #{job.job_id}) (Lock key: #{resource})"
-    end
+      def lock_info(job, resource)
+        "#{job.class.name} (Job ID: #{job.job_id}) (Lock key: #{resource})"
+      end
 
-    def args_info(job)
-      if job.arguments.any? && log_arguments?(job)
-        ' with arguments: ' +
-          job.arguments.map { |arg| format(arg).inspect }.join(', ')
-      else
-        ''
+      def args_info(job)
+        if job.arguments.any? && log_arguments?(job)
+          " with arguments: #{job.arguments.map { |arg| format(arg).inspect }.join(', ')}"
+        else
+          ''
+        end
       end
-    end
 
-    def log_arguments?(job)
-      return true unless job.class.respond_to?(:log_arguments?)
+      def log_arguments?(job)
+        return true unless job.class.respond_to?(:log_arguments?)
 
-      job.class.log_arguments?
-    end
+        job.class.log_arguments?
+      end
 
-    def format(arg)
-      case arg
-      when Hash
-        arg.transform_values { |value| format(value) }
-      when Array
-        arg.map { |value| format(value) }
-      when GlobalID::Identification
-        arg.to_global_id rescue arg
-      else
-        arg
+      def format(arg)
+        case arg
+        when Hash
+          arg.transform_values { |value| format(value) }
+        when Array
+          arg.map { |value| format(value) }
+        when GlobalID::Identification
+          arg.to_global_id rescue arg
+        else
+          arg
+        end
       end
-    end
 
-    def logger
-      ActiveJob::Base.logger
+      def logger
+        ActiveJob::Base.logger
+      end
     end
   end
 end
 
-ActiveJob::LogSubscriber.attach_to :active_job_uniqueness
+ActiveJob::Uniqueness::LogSubscriber.attach_to :active_job_uniqueness

data/lib/active_job/uniqueness/sidekiq_patch.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'activejob/uniqueness'
+require 'sidekiq/api'
+
+module ActiveJob
+  module Uniqueness
+    def self.unlock_sidekiq_job!(job_data)
+      return unless job_data['class'] == 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper' # non ActiveJob jobs
+
+      job = ActiveJob::Base.deserialize(job_data.fetch('args').first)
+
+      return unless job.class.lock_strategy_class
+
+      begin
+        job.send(:deserialize_arguments_if_needed)
+      rescue ActiveJob::DeserializationError
+        # Most probably, GlobalID fails to locate AR record (record is deleted)
+      else
+        ActiveJob::Uniqueness.unlock!(job_class_name: job.class.name, arguments: job.arguments)
+      end
+    end
+
+    module SidekiqPatch
+      module SortedEntry
+        def delete
+          ActiveJob::Uniqueness.unlock_sidekiq_job!(item) if super
+          item
+        end
+
+        private
+
+        def remove_job
+          super do |message|
+            ActiveJob::Uniqueness.unlock_sidekiq_job!(Sidekiq.load_json(message))
+            yield message
+          end
+        end
+      end
+
+      module ScheduledSet
+        def delete(score, job_id)
+          entry = find_job(job_id)
+          ActiveJob::Uniqueness.unlock_sidekiq_job!(entry.item) if super
+          entry
+        end
+      end
+
+      module Job
+        def delete
+          ActiveJob::Uniqueness.unlock_sidekiq_job!(item)
+          super
+        end
+      end
+
+      module Queue
+        def clear
+          each(&:delete)
+          super
+        end
+      end
+
+      module JobSet
+        def clear
+          each(&:delete)
+          super
+        end
+
+        def delete_by_value(name, value)
+          ActiveJob::Uniqueness.unlock_sidekiq_job!(Sidekiq.load_json(value)) if super
+        end
+      end
+    end
+  end
+end
+
+Sidekiq::SortedEntry.prepend ActiveJob::Uniqueness::SidekiqPatch::SortedEntry
+Sidekiq::ScheduledSet.prepend ActiveJob::Uniqueness::SidekiqPatch::ScheduledSet
+Sidekiq::Queue.prepend ActiveJob::Uniqueness::SidekiqPatch::Queue
+Sidekiq::JobSet.prepend ActiveJob::Uniqueness::SidekiqPatch::JobSet
+
+sidekiq_version = Gem::Version.new(Sidekiq::VERSION)
+
+# Sidekiq 6.2.2 renames Sidekiq::Job to Sidekiq::JobRecord
+# https://github.com/mperham/sidekiq/issues/4955
+if sidekiq_version >= Gem::Version.new('6.2.2')
+  Sidekiq::JobRecord.prepend ActiveJob::Uniqueness::SidekiqPatch::Job
+else
+  Sidekiq::Job.prepend ActiveJob::Uniqueness::SidekiqPatch::Job
+end
+
+# Global death handlers are introduced in Sidekiq 5.1
+# https://github.com/mperham/sidekiq/blob/e7acb124fbeb0bece0a7c3d657c39a9cc18d72c6/Changes.md#510
+if sidekiq_version >= Gem::Version.new('7.0')
+  Sidekiq.default_configuration.death_handlers << ->(job, _ex) { ActiveJob::Uniqueness.unlock_sidekiq_job!(job) }
+elsif sidekiq_version >= Gem::Version.new('5.1')
+  Sidekiq.death_handlers << ->(job, _ex) { ActiveJob::Uniqueness.unlock_sidekiq_job!(job) }
+end

data/lib/active_job/uniqueness/strategies/base.rb

@@ -11,12 +11,13 @@ module ActiveJob
 
         delegate :lock_manager, :config, to: :'ActiveJob::Uniqueness'
 
-        attr_reader :lock_key, :lock_ttl, :on_conflict, :job
+        attr_reader :lock_key, :lock_ttl, :on_conflict, :on_redis_connection_error, :job
 
-        def initialize(lock_key:, lock_ttl: nil, on_conflict: nil, job: nil)
-          @lock_key = lock_key
-          @lock_ttl = (lock_ttl || config.lock_ttl).to_i * 1000 # ms
-          @on_conflict = on_conflict || config.on_conflict
+        def initialize(job:)
+          @lock_key = job.lock_key
+          @lock_ttl = (job.lock_options[:lock_ttl] || config.lock_ttl).to_i * 1000 # ms
+          @on_conflict = job.lock_options[:on_conflict] || config.on_conflict
+          @on_redis_connection_error = job.lock_options[:on_redis_connection_error] || config.on_redis_connection_error
           @job = job
         end
 
@@ -60,6 +61,12 @@ module ActiveJob
 
             handle_conflict(resource: lock_key, on_conflict: on_conflict)
             abort_job
+          rescue RedisClient::ConnectionError => e
+            handle_redis_connection_error(
+              resource: lock_key, on_redis_connection_error:
+              on_redis_connection_error, error: e
+            )
+            abort_job
           end
 
           def around_enqueue(block)
@@ -86,6 +93,14 @@ module ActiveJob
           end
         end
 
+        def handle_redis_connection_error(resource:, on_redis_connection_error:, error:)
+          case on_redis_connection_error
+          when :raise, nil then raise error
+          else
+            on_redis_connection_error.call(job, resource: resource, error: error)
+          end
+        end
+
         def abort_job
           @job_aborted = true # ActiveJob 4.2 workaround
 

data/lib/active_job/uniqueness/strategies/until_and_while_executing.rb

@@ -9,12 +9,16 @@ module ActiveJob
       class UntilAndWhileExecuting < Base
         include LockingOnEnqueue
 
-        attr_reader :runtime_lock_ttl, :on_runtime_conflict
+        attr_reader :runtime_lock_key, :runtime_lock_ttl, :on_runtime_conflict
 
-        def initialize(runtime_lock_ttl: nil, on_runtime_conflict: nil, **params)
-          super(params)
-          @runtime_lock_ttl = runtime_lock_ttl.present? ? runtime_lock_ttl.to_i * 1000 : lock_ttl
-          @on_runtime_conflict = on_runtime_conflict || on_conflict
+        def initialize(job:)
+          super
+          @runtime_lock_key = job.runtime_lock_key
+
+          runtime_lock_ttl_option = job.lock_options[:runtime_lock_ttl]
+          @runtime_lock_ttl = runtime_lock_ttl_option.present? ? runtime_lock_ttl_option.to_i * 1000 : lock_ttl
+
+          @on_runtime_conflict = job.lock_options[:on_runtime_conflict] || on_conflict
         end
 
         def before_perform
@@ -33,10 +37,6 @@ module ActiveJob
         ensure
           unlock(resource: runtime_lock_key, event: :runtime_unlock) unless @job_aborted
         end
-
-        def runtime_lock_key
-          [lock_key, 'runtime'].join(':')
-        end
       end
     end
   end

data/lib/active_job/uniqueness/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveJob
   module Uniqueness
-    VERSION = '0.1.2'
+    VERSION = '0.4.0'
   end
 end

data/lib/active_job/uniqueness.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require 'active_support'
-require 'active_support/core_ext'
+require 'active_job'
 require 'redlock'
-require 'openssl'
+
 require 'active_job/uniqueness/version'
 require 'active_job/uniqueness/errors'
 require 'active_job/uniqueness/log_subscriber'
-require 'active_job/uniqueness/patch'
+require 'active_job/uniqueness/active_job_patch'
 
 module ActiveJob
   module Uniqueness
@@ -32,13 +31,17 @@ module ActiveJob
         @lock_manager ||= ActiveJob::Uniqueness::LockManager.new(config.redlock_servers, config.redlock_options)
       end
 
-      def unlock!(*args)
-        lock_manager.delete_locks(ActiveJob::Uniqueness::LockKey.new(*args).wildcard_key)
+      def unlock!(**args)
+        lock_manager.delete_locks(ActiveJob::Uniqueness::LockKey.new(**args).wildcard_key)
       end
 
       def test_mode!
         @lock_manager = ActiveJob::Uniqueness::TestLockManager.new
       end
+
+      def reset_manager!
+        @lock_manager = nil
+      end
     end
   end
 end

data/lib/generators/active_job/uniqueness/templates/config/initializers/active_job_uniqueness.rb

@@ -2,7 +2,7 @@
 
 ActiveJob::Uniqueness.configure do |config|
   # Global default expiration for lock keys. Each job can define its own ttl via :lock_ttl option.
-  # Stategy :until_and_while_executing also accept :on_runtime_ttl option.
+  # Strategy :until_and_while_executing also accepts :on_runtime_ttl option.
   #
   # config.lock_ttl = 1.day
 
@@ -11,14 +11,21 @@ ActiveJob::Uniqueness.configure do |config|
   # config.lock_prefix = 'activejob_uniqueness'
 
   # Default action on lock conflict. Can be set per job.
-  # Stategy :until_and_while_executing also accept :on_runtime_conflict option.
+  # Strategy :until_and_while_executing also accepts :on_runtime_conflict option.
   # Allowed values are
   #   :raise - raises ActiveJob::Uniqueness::JobNotUnique
   #   :log - instruments ActiveSupport::Notifications and logs event to the ActiveJob::Logger
-  #   proc - custom Proc. For example, ->(job) { job.logger.info('Oops') }
+  #   proc - custom Proc. For example, ->(job) { job.logger.info("Job already in queue: #{job.class.name} #{job.arguments.inspect} (#{job.job_id})") }
   #
   # config.on_conflict = :raise
 
+  # Default action on redis connection error. Can be set per job.
+  # Allowed values are
+  #   :raise - raises ActiveJob::Uniqueness::JobNotUnique
+  #   proc - custom Proc. For example, ->(job, resource: _, error: _) { job.logger.info("Job already in queue: #{job.class.name} #{job.arguments.inspect} (#{job.job_id})") }
+  #
+  # config.on_redis_connection_error = :raise
+
   # Digest method for lock keys generating. Expected to have `hexdigest` class method.
   #
   # config.digest_method = OpenSSL::Digest::MD5
@@ -31,7 +38,7 @@ ActiveJob::Uniqueness.configure do |config|
   # Custom options for Redlock.
   # Read more at https://github.com/leandromoreira/redlock-rb#redlock-configuration
   #
-  # config.redlock_options = {}
+  # config.redlock_options = { retry_count: 0 }
 
   # Custom strategies.
   # config.lock_strategies = { my_strategy: MyStrategy }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activejob-uniqueness
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Rustam Sharshenov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-30 00:00:00.000000000 Z
+date: 2024-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,68 +27,71 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
 - !ruby/object:Gem::Dependency
   name: redlock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.3.0
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.6.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.6.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -100,6 +106,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.28'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.28'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
 description: Ensure uniqueness of your ActiveJob jobs
 email:
 - rustam@sharshenov.com
@@ -107,24 +141,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".rubocop.yml"
-- ".travis.yml"
 - CHANGELOG.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- activejob-uniqueness.gemspec
 - lib/active_job/uniqueness.rb
+- lib/active_job/uniqueness/active_job_patch.rb
 - lib/active_job/uniqueness/configuration.rb
 - lib/active_job/uniqueness/errors.rb
 - lib/active_job/uniqueness/lock_key.rb
 - lib/active_job/uniqueness/lock_manager.rb
 - lib/active_job/uniqueness/log_subscriber.rb
-- lib/active_job/uniqueness/patch.rb
-- lib/active_job/uniqueness/patch/sidekiq.rb
+- lib/active_job/uniqueness/sidekiq_patch.rb
 - lib/active_job/uniqueness/strategies.rb
 - lib/active_job/uniqueness/strategies/base.rb
 - lib/active_job/uniqueness/strategies/until_and_while_executing.rb
@@ -143,7 +170,8 @@ licenses:
 metadata:
   homepage_uri: https://github.com/veeqo/activejob-uniqueness
   source_code_uri: https://github.com/veeqo/activejob-uniqueness
-  changelog_uri: https://github.com/veeqo/activejob-uniqueness/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/veeqo/activejob-uniqueness/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -152,14 +180,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.2.33
 signing_key: 
 specification_version: 4
 summary: Ensure uniqueness of your ActiveJob jobs

data/.gitignore

@@ -1,14 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-/Gemfile.lock
-/.ruby-gemset
-/.ruby-version
-
-# rspec failure tracking
-.rspec_status

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper