activejob-uniqueness 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 120483e1019cb9e65e1f270ae21d040d17a37d54e7fa6616800cdc7ff8180251
-  data.tar.gz: c9b299e5e444e19cb1f2a3230447eb44ebd719bb2a93e3c0b2abe22f77782e47
+  metadata.gz: cd76f286ed7e6482860247e9b98b754dc1b73a381fcd2579d73e469da95d0200
+  data.tar.gz: 866f0949c68745c168217cbc70b10c65799f70aa372902dbd145781726217acd
 SHA512:
-  metadata.gz: 5742577b735a3749612b194b6d8912a72938ffaab6b2cb470448fce0342c39a265e99a0fa043f405eaf90ef03f1844fa913331095d13a9a9f968ece3e75265fa
-  data.tar.gz: 4d22df0933705d5aa22fec6d47add7a6d61e6adab20afb9d8a0557cc6c35907d75491ac07a1bd0e71ea2e4fb59a6d6468ece7e8387c2ee954cc6e1078aa55326
+  metadata.gz: 5cb9299a82cc40a9fca3df73c771cf553ead9393b11eca505afea5e55fe3023722db67d509528d0886db66e64569ba1caea04622ebde3ca365df1d768f04d2f4
+  data.tar.gz: 205d78f3c41721bce16c16d991204423fe5429b23c1d6fad48eb1a4ac7f775057f7e15192e8d1c32c97fc0c2c4af60a1584d6a666c253df71e1acce9ba02e5fa

data/CHANGELOG.md

@@ -3,7 +3,26 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
-## [Unreleased](https://github.com/veeqo/activejob-uniqueness/compare/v0.3.1...HEAD)
+## [Unreleased](https://github.com/veeqo/activejob-uniqueness/compare/v0.4.0...HEAD)
+
+
+## [0.4.0](https://github.com/veeqo/activejob-uniqueness/compare/v0.3.2...v0.4.0) - 2024-12-07
+
+### Added
+
+- [#86](https://github.com/veeqo/activejob-uniqueness/pull/86) Add Rails 8.0 rc1 support by[@sharshenov](https://github.com/sharshenov)
+- [#78](https://github.com/veeqo/activejob-uniqueness/pull/78) Add on_redis_connection_error config to adjust to new redlock behaviour by[@nduitz](https://github.com/nduitz)
+
+### Changed
+- [#82](https://github.com/veeqo/activejob-uniqueness/pull/82) Optimize bulk unlocking [@sharshenov](https://github.com/sharshenov)
+
+## [0.3.2](https://github.com/veeqo/activejob-uniqueness/compare/v0.3.1...v0.3.2) - 2024-08-16
+
+### Added
+- [#80](https://github.com/veeqo/activejob-uniqueness/pull/80) Add rails 7.2 support by [@viralpraxis](https://github.com/viralpraxis)
+
+### Changed
+- [#74](https://github.com/veeqo/activejob-uniqueness/pull/74) Fix log subscriber by [@shahidkhaliq](https://github.com/shahidkhaliq)
 
 ## [0.3.1](https://github.com/veeqo/activejob-uniqueness/compare/v0.3.0...v0.3.1) - 2023-10-30
 

data/README.md

@@ -43,6 +43,19 @@ To override the defaults, create an initializer `config/initializers/active_job_
 rails generate active_job:uniqueness:install
 ```
 
+This gem relies on `redlock` for it's Redis connection, that means **it will not inherit global configuration of `Sidekiq`**. To configure the connection, you can use `config.redlock_servers`, for example to disable SSL verification for Redis/Key-Value cloud providers:
+
+```ruby
+ActiveJob::Uniqueness.configure do |config|
+  config.redlock_servers = [
+    RedisClient.new(
+      url: ENV['REDIS_URL'],
+      ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE }
+    )
+  ]
+end
+```
+
 ## Usage
 
 
@@ -87,6 +100,19 @@ class MyJob < ActiveJob::Base
 end
 ```
 
+### Control redis connection errors
+
+```ruby
+class MyJob < ActiveJob::Base
+  # Proc gets the job instance including its arguments, and as keyword arguments the resource(lock key) `resource` and the original error `error`
+  unique :until_executing, on_redis_connection_error: ->(job, resource: _, error: _) { job.logger.info "Oops: #{job.arguments}" }
+
+  def perform(args)
+    # work
+  end
+end
+```
+
 ### Control lock key arguments
 
 ```ruby

data/lib/active_job/uniqueness/active_job_patch.rb

@@ -27,6 +27,7 @@ module ActiveJob
         def unique(strategy, options = {})
           validate_on_conflict_action!(options[:on_conflict])
           validate_on_conflict_action!(options[:on_runtime_conflict])
+          validate_on_redis_connection_error!(options[:on_redis_connection_error])
 
           self.lock_strategy_class = ActiveJob::Uniqueness::Strategies.lookup(strategy)
           self.lock_options = options
@@ -40,7 +41,9 @@ module ActiveJob
 
         private
 
-        delegate :validate_on_conflict_action!, to: :'ActiveJob::Uniqueness.config'
+        delegate :validate_on_conflict_action!,
+                 :validate_on_redis_connection_error!,
+                 to: :'ActiveJob::Uniqueness.config'
       end
 
       included do

data/lib/active_job/uniqueness/configuration.rb

@@ -14,6 +14,7 @@ module ActiveJob
       config_accessor(:lock_ttl) { 86_400 } # 1.day
       config_accessor(:lock_prefix) { 'activejob_uniqueness' }
       config_accessor(:on_conflict) { :raise }
+      config_accessor(:on_redis_connection_error) { :raise }
       config_accessor(:redlock_servers) { [ENV.fetch('REDIS_URL', 'redis://localhost:6379')] }
       config_accessor(:redlock_options) { { retry_count: 0 } }
       config_accessor(:lock_strategies) { {} }
@@ -34,6 +35,18 @@ module ActiveJob
 
         raise ActiveJob::Uniqueness::InvalidOnConflictAction, "Unexpected '#{action}' action on conflict"
       end
+
+      def on_redis_connection_error=(action)
+        validate_on_redis_connection_error!(action)
+
+        config.on_redis_connection_error = action
+      end
+
+      def validate_on_redis_connection_error!(action)
+        return if action.nil? || action == :raise || action.respond_to?(:call)
+
+        raise ActiveJob::Uniqueness::InvalidOnConflictAction, "Unexpected '#{action}' action on_redis_connection_error"
+      end
     end
   end
 end

data/lib/active_job/uniqueness/lock_manager.rb

@@ -17,11 +17,17 @@ module ActiveJob
         true
       end
 
+      DELETE_LOCKS_SCAN_COUNT = 1000
+
       # Unlocks multiple resources by key wildcard.
       def delete_locks(wildcard)
         @servers.each do |server|
           synced_redis_connection(server) do |conn|
-            conn.scan('MATCH', wildcard).each { |key| conn.call('DEL', key) }
+            cursor = 0
+            while cursor != '0'
+              cursor, keys = conn.call('SCAN', cursor, 'MATCH', wildcard, 'COUNT', DELETE_LOCKS_SCAN_COUNT)
+              conn.call('UNLINK', *keys) unless keys.empty?
+            end
           end
         end
 

data/lib/active_job/uniqueness/log_subscriber.rb

@@ -3,98 +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

@@ -41,7 +41,7 @@ module ActiveJob
       module ScheduledSet
         def delete(score, job_id)
           entry = find_job(job_id)
-          ActiveJob::Uniqueness.unlock_sidekiq_job!(entry.item) if super(score, job_id)
+          ActiveJob::Uniqueness.unlock_sidekiq_job!(entry.item) if super
           entry
         end
       end
@@ -67,7 +67,7 @@ module ActiveJob
         end
 
         def delete_by_value(name, value)
-          ActiveJob::Uniqueness.unlock_sidekiq_job!(Sidekiq.load_json(value)) if super(name, value)
+          ActiveJob::Uniqueness.unlock_sidekiq_job!(Sidekiq.load_json(value)) if super
         end
       end
     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(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/version.rb

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

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

@@ -19,6 +19,13 @@ ActiveJob::Uniqueness.configure do |config|
   #
   # 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activejob-uniqueness
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Rustam Sharshenov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-30 00:00:00.000000000 Z
+date: 2024-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -19,7 +19,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '8.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '8.1'
 - !ruby/object:Gem::Dependency
   name: redlock
   requirement: !ruby/object:Gem::Requirement