sidekiq-unique-jobs 7.0.13 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31de42f9427b913ae2c311fe70bd63c1ebed4dba96de6837d5e1f489644f7222
-  data.tar.gz: 46a500dc20edc1cbaa562a27ad66522819359deead834a97cf7bd08d1c50cc08
+  metadata.gz: e47af152a018a49730a81e9f77ad68debea6a82d1750c6f41e8375be664da2bc
+  data.tar.gz: 3bbb5a4fdb354b6c49e774e26c525b8a5678e83d4a1deb156d544522e76ecf3e
 SHA512:
-  metadata.gz: b8fd43403d772a57add9fa5a6d1fef4e728b53e14a72df440e68eb345d6e3a867132de697ad483fd197ebfe3bc77bc2d80ab17af5727eac96c69ef31e29d4447
-  data.tar.gz: fa2ecad50220f6cf6cb2b72666094f1761cb1c2671a505d4d804374b50b08a4b78b80ba82561f4a45f3108eb6098b8d2dd2ebfef4683aac226849412cb0eb1f9
+  metadata.gz: 0c4d4c979b44940d230d3ad0f3df7487f223b2545aae90eca00eddf0b05fb450fe21beb924929aa40c53bb012fa01cd82e0e611136048370c33baea0375bb184
+  data.tar.gz: 289cbba203cde12c4c070057fd642843d036f12f4623c70ecd3e9c5a777f12f416ea567e971512a86fe8556df4e03316b726f1320096655d0c54ada469758f94

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [v7.0.12](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v7.0.12) (2021-06-04)
+
+[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v7.0.11...v7.0.12)
+
+**Implemented enhancements:**
+
+- Reduce noise of perfectly valid scenario [\#610](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/610) ([mhenrixon](https://github.com/mhenrixon))
+
+**Merged pull requests:**
+
+- Set correct namespace for custom strategy example [\#609](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/609) ([Wolfer](https://github.com/Wolfer))
+- Clarify the documentation related to lock\_ttl [\#607](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/607) ([donaldpiret](https://github.com/donaldpiret))
+
 ## [v7.0.11](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v7.0.11) (2021-05-16)
 
 [Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v7.0.10...v7.0.11)

data/README.md

@@ -12,6 +12,18 @@
 - [Support Me](#support-me)
 - [Requirements](#requirements)
 - [General Information](#general-information)
+- [Reflections \(metrics, logging, etc.\)](#reflections-metrics-logging-etc)
+  - [after_unlock_callback_failed](#after_unlock_callback_failed)
+  - [error](#error)
+  - [execution_failed](#execution_failed)
+  - [lock_failed](#lock_failed)
+  - [locked](#locked)
+  - [reschedule_failed](#reschedule_failed)
+  - [rescheduled](#rescheduled)
+  - [timeout](#timeout)
+  - [unlock_failed](#unlock_failed)
+  - [unlocked](#unlocked)
+  - [unknown_sidekiq_worker](#unknown_sidekiq_worker)
 - [Global Configuration](#global-configuration)
   - [debug_lua](#debug_lua)
   - [lock_timeout](#lock_timeout)
@@ -49,7 +61,6 @@
 - [Usage](#usage-1)
   - [Finer Control over Uniqueness](#finer-control-over-uniqueness)
   - [After Unlock Callback](#after-unlock-callback)
-  - [Logging](#logging)
   - [Cleanup Dead Locks](#cleanup-dead-locks)
   - [Other Sidekiq gems](#other-sidekiq-gems)
     - [apartment-sidekiq](#apartment-sidekiq)
@@ -130,20 +141,16 @@ end
 
 ### Your first worker
 
+The most likely to be used worker is `:until_executed`. This type of lock creates a lock from when `UntilExecutedWorker.perform_async` is called until the the sidekiq processor has processed the job.
+
 ```ruby
 # frozen_string_literal: true
 
 class UntilExecutedWorker
   include Sidekiq::Worker
 
-  sidekiq_options queue: :special,
-                  retry: false,
-                  lock: :until_executed,
-                  lock_info: true,
-                  lock_timeout: 0,
-                  lock_prefix: "special",
-                  lock_ttl: 0,
-                  lock_limit: 5
+  sidekiq_options queue: :until_executed,
+                  lock: :until_executed
 
   def perform
     logger.info("cowboy")
@@ -151,7 +158,6 @@ class UntilExecutedWorker
     logger.info("beebop")
   end
 end
-
 ```
 
 You can read more about the worker configuration in [Worker Configuration](#worker-configuration) below.
@@ -179,6 +185,82 @@ See [Interaction w/ Sidekiq](https://github.com/mhenrixon/sidekiq-unique-jobs/wi
 
 See [Locking & Unlocking](https://github.com/mhenrixon/sidekiq-unique-jobs/wiki/Locking-&-Unlocking) for an overview of the differences on when the various lock types are locked and unlocked.
 
+## Reflections (metrics, logging, etc.)
+
+To be able to gather some insights on what is going on inside this gem. I provide a reflection API that can be used.
+
+To setup reflections for logging or metrics, use the following API:
+
+```ruby
+
+def extract_log_from_job(message, job_hash)
+  worker    = job_hash['class']
+  args      = job_hash['args']
+  lock_args = job_hash['lock_args']
+  queue     = job_hash['queue']
+  {
+    message: message,
+    worker: worker,
+    args: args,
+    lock_args: lock_args,
+    queue: queue
+  }
+end
+
+SidekiqUniqueJobs.reflect do |on|
+  on.lock_failed do |job_hash|
+    message = extract_log_from_job('Lock Failed', job_hash)
+    Sidekiq.logger.warn(message)
+  end
+end
+```
+
+### after_unlock_callback_failed
+
+This is called when you have configured a custom callback for when a lock has been released.
+
+### error
+
+Not in use yet but will be used deep into the stack to provide a means to catch and report errors inside the gem.
+
+### execution_failed
+
+When the sidekiq processor picks the job of the queue for certain jobs but your job raised an error to the middleware. This will be the reflection. It is probably nothing to worry about. When your worker raises an error, we need to handle some edge cases for until and while executing.
+
+### lock_failed
+
+If we can't achieve a lock, this will be the reflection. It most likely is nothing to worry about. We just couldn't retrieve a lock in a timely fashion.
+
+The biggest reason for this reflection would be to gather metrics on which workers fail the most at the locking step for example.
+
+### locked
+
+For when a lock has been successful. Again, mostly useful for metrics I suppose.
+
+### reschedule_failed
+
+For when the reschedule strategy failed to reschedule the job.
+
+### rescheduled
+
+For when a job was successfully rescheduled
+
+### timeout
+
+This is also mostly useful for reporting/metrics purposes. What this reflection does is signal that the job was configured to wait (`lock_timeout` was configured), but we couldn't retrieve a lock even though we waited for some time.
+
+### unlock_failed
+
+This is not got, this is worth
+
+### unlocked
+
+Also mostly useful for reporting purposes. The job was successfully unlocked.
+
+### unknown_sidekiq_worker
+
+The reason this happens is that the server couldn't find a valid sidekiq worker class. Most likely, that worker isn't intended to be processed by this sidekiq server instance.
+
 ## Global Configuration
 
 The gem supports a few different configuration options that might be of interest if you run into some weird issues.
@@ -683,21 +765,6 @@ class UniqueJobWithFilterMethod
 end.
 ```
 
-### Logging
-
-To see logging in sidekiq when duplicate payload has been filtered out you can enable on a per worker basis using the sidekiq options. The default value is false
-
-```ruby
-class UniqueJobWithFilterMethod
-  include Sidekiq::Worker
-  sidekiq_options lock: :while_executing,
-                  log_duplicate: true
-
-  ...
-
-end
-```
-
 ### Cleanup Dead Locks
 
 For sidekiq versions before 5.1 a `sidekiq_retries_exhausted` block is required per worker class. This is deprecated in Sidekiq 6.0

data/lib/sidekiq_unique_jobs/config.rb

@@ -16,6 +16,8 @@ module SidekiqUniqueJobs
                                                    :reaper_count,
                                                    :reaper_interval,
                                                    :reaper_timeout,
+                                                   :reaper_resurrector_interval,
+                                                   :reaper_resurrector_enabled,
                                                    :lock_info,
                                                    :raise_on_config_error,
                                                    :current_redis_version)
@@ -109,6 +111,14 @@ module SidekiqUniqueJobs
     #
     # @return [10] stop reaper after 10 seconds
     REAPER_TIMEOUT        = 10
+    #
+    # @return [3600] check if reaper is dead each 3600 seconds
+    REAPER_RESURRECTOR_INTERVAL = 3600
+
+    #
+    # @return [true] enable reaper resurrector
+    REAPER_RESURRECTOR_ENABLED = true
+
     #
     # @return [false] while useful it also adds overhead so disable lock_info by default
     USE_LOCK_INFO         = false
@@ -178,6 +188,8 @@ module SidekiqUniqueJobs
         REAPER_COUNT,
         REAPER_INTERVAL,
         REAPER_TIMEOUT,
+        REAPER_RESURRECTOR_INTERVAL,
+        REAPER_RESURRECTOR_ENABLED,
         USE_LOCK_INFO,
         RAISE_ON_CONFIG_ERROR,
         REDIS_VERSION,
@@ -185,26 +197,22 @@ module SidekiqUniqueJobs
     end
 
     def default_lock_ttl=(obj)
-      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated." \
-           " Please use `#{class_name}#lock_ttl=` instead."
+      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated. Please use `#{class_name}#lock_ttl=` instead."
       self.lock_ttl = obj
     end
 
     def default_lock_timeout=(obj)
-      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated." \
-           " Please use `#{class_name}#lock_timeout=` instead."
+      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated. Please use `#{class_name}#lock_timeout=` instead."
       self.lock_timeout = obj
     end
 
     def default_lock_ttl
-      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated." \
-           " Please use `#{class_name}#lock_ttl` instead."
+      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated. Please use `#{class_name}#lock_ttl` instead."
       lock_ttl
     end
 
     def default_lock_timeout
-      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated." \
-           " Please use `#{class_name}#lock_timeout` instead."
+      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated. Please use `#{class_name}#lock_timeout` instead."
       lock_timeout
     end
 

data/lib/sidekiq_unique_jobs/constants.rb

@@ -6,49 +6,48 @@
 # @author Mikael Henriksson <mikael@mhenrixon.com>
 #
 module SidekiqUniqueJobs
-  ARGS                  = "args"
-  APARTMENT             = "apartment"
-  AT                    = "at"
-  CHANGELOGS            = "uniquejobs:changelog"
-  CLASS                 = "class"
-  CREATED_AT            = "created_at"
-  DEAD_VERSION          = "uniquejobs:dead"
-  DIGESTS               = "uniquejobs:digests"
-  ERRORS                = "errors"
-  JID                   = "jid"
-  LIMIT                 = "limit"
-  LIVE_VERSION          = "uniquejobs:live"
-  LOCK                  = "lock"
-  LOCK_ARGS             = "lock_args"
-  LOCK_ARGS_METHOD      = "lock_args_method"
-  LOCK_DIGEST           = "lock_digest"
-  LOCK_EXPIRATION       = "lock_expiration"
-  LOCK_INFO             = "lock_info"
-  LOCK_LIMIT            = "lock_limit"
-  LOCK_PREFIX           = "lock_prefix"
-  LOCK_TIMEOUT          = "lock_timeout"
-  LOCK_TTL              = "lock_ttl"
-  LOCK_TYPE             = "lock_type"
-  LOG_DUPLICATE         = "log_duplicate"
-  ON_CLIENT_CONFLICT    = "on_client_conflict"
-  ON_CONFLICT           = "on_conflict"
-  ON_SERVER_CONFLICT    = "on_server_conflict"
-  PAYLOAD               = "payload"
-  PROCESSES             = "processes"
-  QUEUE                 = "queue"
-  RETRY                 = "retry"
-  SCHEDULE              = "schedule"
-  TIME                  = "time"
-  TIMEOUT               = "timeout"
-  TTL                   = "ttl"
-  TYPE                  = "type"
-  UNIQUE                = "unique"
-  UNIQUE_ACROSS_QUEUES  = "unique_across_queues"
-  UNIQUE_ACROSS_WORKERS = "unique_across_workers"
-  UNIQUE_ARGS           = "unique_args"
-  UNIQUE_ARGS_METHOD    = "unique_args_method"
-  UNIQUE_DIGEST         = "unique_digest"
-  UNIQUE_PREFIX         = "unique_prefix"
-  UNIQUE_REAPER         = "uniquejobs:reaper"
-  WORKER                = "worker"
+  ARGS                  ||= "args"
+  APARTMENT             ||= "apartment"
+  AT                    ||= "at"
+  CHANGELOGS            ||= "uniquejobs:changelog"
+  CLASS                 ||= "class"
+  CREATED_AT            ||= "created_at"
+  DEAD_VERSION          ||= "uniquejobs:dead"
+  DIGESTS               ||= "uniquejobs:digests"
+  ERRORS                ||= "errors"
+  JID                   ||= "jid"
+  LIMIT                 ||= "limit"
+  LIVE_VERSION          ||= "uniquejobs:live"
+  LOCK                  ||= "lock"
+  LOCK_ARGS             ||= "lock_args"
+  LOCK_ARGS_METHOD      ||= "lock_args_method"
+  LOCK_DIGEST           ||= "lock_digest"
+  LOCK_EXPIRATION       ||= "lock_expiration"
+  LOCK_INFO             ||= "lock_info"
+  LOCK_LIMIT            ||= "lock_limit"
+  LOCK_PREFIX           ||= "lock_prefix"
+  LOCK_TIMEOUT          ||= "lock_timeout"
+  LOCK_TTL              ||= "lock_ttl"
+  LOCK_TYPE             ||= "lock_type"
+  ON_CLIENT_CONFLICT    ||= "on_client_conflict"
+  ON_CONFLICT           ||= "on_conflict"
+  ON_SERVER_CONFLICT    ||= "on_server_conflict"
+  PAYLOAD               ||= "payload"
+  PROCESSES             ||= "processes"
+  QUEUE                 ||= "queue"
+  RETRY                 ||= "retry"
+  SCHEDULE              ||= "schedule"
+  TIME                  ||= "time"
+  TIMEOUT               ||= "timeout"
+  TTL                   ||= "ttl"
+  TYPE                  ||= "type"
+  UNIQUE                ||= "unique"
+  UNIQUE_ACROSS_QUEUES  ||= "unique_across_queues"
+  UNIQUE_ACROSS_WORKERS ||= "unique_across_workers"
+  UNIQUE_ARGS           ||= "unique_args"
+  UNIQUE_ARGS_METHOD    ||= "unique_args_method"
+  UNIQUE_DIGEST         ||= "unique_digest"
+  UNIQUE_PREFIX         ||= "unique_prefix"
+  UNIQUE_REAPER         ||= "uniquejobs:reaper"
+  WORKER                ||= "worker"
 end

data/lib/sidekiq_unique_jobs/deprecation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Class Deprecation provides logging of deprecations
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
+  class Deprecation
+    def self.muted
+      orig_val = Thread.current[:uniquejobs_mute_deprecations]
+      Thread.current[:uniquejobs_mute_deprecations] = true
+      yield
+    ensure
+      Thread.current[:uniquejobs_mute_deprecations] = orig_val
+    end
+
+    def self.muted?
+      Thread.current[:uniquejobs_mute_deprecations] == true
+    end
+
+    def self.warn(msg)
+      return if SidekiqUniqueJobs::Deprecation.muted?
+
+      warn "DEPRECATION WARNING: #{msg}"
+    end
+
+    def self.warn_with_backtrace(msg)
+      return if SidekiqUniqueJobs::Deprecation.muted?
+
+      trace = "\n\nCALLED FROM:\n#{caller.join("\n")}"
+      warn(msg + trace)
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/exceptions.rb

@@ -18,6 +18,15 @@ module SidekiqUniqueJobs
     end
   end
 
+  #
+  # Raised when no block was given
+  #
+  class NoBlockGiven < SidekiqUniqueJobs::UniqueJobsError; end
+  #
+  # Raised when a notification has been mistyped
+  #
+  class NoSuchNotificationError < UniqueJobsError; end
+
   #
   # Error raised when trying to add a duplicate lock
   #

data/lib/sidekiq_unique_jobs/lock/base_lock.rb

@@ -7,8 +7,16 @@ module SidekiqUniqueJobs
     # @abstract
     # @author Mikael Henriksson <mikael@mhenrixon.com>
     class BaseLock
+      extend Forwardable
+
+      # includes "SidekiqUniqueJobs::Logging"
+      # @!parse include SidekiqUniqueJobs::Logging
       include SidekiqUniqueJobs::Logging
 
+      # includes "SidekiqUniqueJobs::Reflectable"
+      # @!parse include SidekiqUniqueJobs::Reflectable
+      include SidekiqUniqueJobs::Reflectable
+
       #
       # Validates that the sidekiq_options for the worker is valid
       #
@@ -20,6 +28,10 @@ module SidekiqUniqueJobs
         Validator.validate(options)
       end
 
+      # NOTE: Mainly used for a clean testing API
+      #
+      def_delegators :locksmith, :locked?
+
       # @param [Hash] item the Sidekiq job hash
       # @param [Proc] callback the callback to use after unlock
       # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
@@ -41,10 +53,8 @@ module SidekiqUniqueJobs
       #
       # @yield to the caller when given a block
       #
-      def lock(&block)
-        return call_strategy unless (locked_token = locksmith.lock(&block))
-
-        locked_token
+      def lock
+        raise NotImplementedError, "##{__method__} needs to be implemented in #{self.class}"
       end
 
       # Execute the job in the Sidekiq server processor
@@ -53,31 +63,6 @@ module SidekiqUniqueJobs
         raise NotImplementedError, "##{__method__} needs to be implemented in #{self.class}"
       end
 
-      # Unlocks the job from redis
-      # @return [String] sidekiq job id when successful
-      # @return [false] when unsuccessful
-      def unlock
-        locksmith.unlock # Only signal to release the lock
-      end
-
-      # Deletes the job from redis if it is locked.
-      def delete
-        locksmith.delete # Soft delete (don't forcefully remove when expiration is set)
-      end
-
-      # Forcefully deletes the job from redis.
-      #   This is good for jobs when a previous lock was not unlocked
-      def delete!
-        locksmith.delete! # Force delete the lock
-      end
-
-      # Checks if the item has achieved a lock
-      # @return [true] when this jid has locked the job
-      # @return [false] when this jid has not locked the job
-      def locked?
-        locksmith.locked?
-      end
-
       #
       # The lock manager/client
       #
@@ -90,23 +75,6 @@ module SidekiqUniqueJobs
 
       private
 
-      def prepare_item
-        return if item.key?(LOCK_DIGEST)
-
-        # The below should only be done to ease testing
-        # in production this will be done by the middleware
-        SidekiqUniqueJobs::Job.prepare(item)
-      end
-
-      def call_strategy
-        @attempt += 1
-        client_strategy.call { lock if replace? }
-      end
-
-      def replace?
-        client_strategy.replace? && attempt < 2
-      end
-
       # @!attribute [r] item
       #   @return [Hash<String, Object>] the Sidekiq job hash
       attr_reader :item
@@ -123,18 +91,55 @@ module SidekiqUniqueJobs
       #   @return [Integer] the current locking attempt
       attr_reader :attempt
 
-      def unlock_with_callback
-        return log_warn("Might need to be unlocked manually", item) unless unlock
+      def prepare_item
+        return if item.key?(LOCK_DIGEST)
 
-        callback_safely
-        item[JID]
+        # The below should only be done to ease testing
+        # in production this will be done by the middleware
+        SidekiqUniqueJobs::Job.prepare(item)
+      end
+
+      #
+      # Handle when lock failed
+      #
+      # @param [Symbol] location: :client or :server
+      #
+      # @return [void]
+      #
+      def lock_failed(origin: :client)
+        reflect(:lock_failed, item)
+        call_strategy(origin: origin)
+      end
+
+      def call_strategy(origin:)
+        @attempt += 1
+
+        case origin
+        when :client
+          client_strategy.call { lock if replace? }
+        when :server
+          server_strategy.call { lock if replace? }
+        else
+          raise SidekiqUniqueJobs::InvalidArgument,
+                "either `for: :server` or `for: :client` needs to be specified"
+        end
+      end
+
+      def replace?
+        client_strategy.replace? && attempt < 2
+      end
+
+      def unlock_and_callback
+        return callback_safely if locksmith.unlock
+
+        reflect(:unlock_failed, item)
       end
 
       def callback_safely
         callback&.call
         item[JID]
       rescue StandardError
-        log_warn("Unlocked successfully but the #after_unlock callback failed!", item)
+        reflect(:after_unlock_callback_failed, item)
         raise
       end
 

data/lib/sidekiq_unique_jobs/lock/until_and_while_executing.rb

@@ -13,30 +13,52 @@ module SidekiqUniqueJobs
     #
     # @author Mikael Henriksson <mikael@mhenrixon.com>
     class UntilAndWhileExecuting < BaseLock
+      #
+      # Locks a sidekiq job
+      #
+      # @note Will call a conflict strategy if lock can't be achieved.
+      #
+      # @return [String, nil] the locked jid when properly locked, else nil.
+      #
+      # @yield to the caller when given a block
+      #
+      def lock(origin: :client)
+        return lock_failed(origin: origin) unless (token = locksmith.lock)
+        return yield token if block_given?
+
+        token
+      end
+
       # Executes in the Sidekiq server process
       # @yield to the worker class perform method
       def execute
-        if unlock
-          lock_on_failure do
-            runtime_lock.execute { return yield }
-          end
+        if locksmith.unlock
+          # ensure_relocked do
+          runtime_lock.execute { return yield }
+          # end
         else
-          log_warn("Couldn't unlock digest: #{item[LOCK_DIGEST]}, jid: #{item[JID]}")
+          reflect(:unlock_failed, item)
         end
+      rescue Exception # rubocop:disable Lint/RescueException
+        reflect(:execution_failed, item)
+        locksmith.lock(wait: 2)
+
+        raise
       end
 
       private
 
-      def lock_on_failure
+      def ensure_relocked
         yield
       rescue Exception # rubocop:disable Lint/RescueException
-        log_error("Runtime lock failed to execute job, restoring server lock", item)
-        lock
+        reflect(:execution_failed, item)
+        locksmith.lock
+
         raise
       end
 
       def runtime_lock
-        @runtime_lock ||= SidekiqUniqueJobs::Lock::WhileExecuting.new(item, callback, redis_pool)
+        @runtime_lock ||= SidekiqUniqueJobs::Lock::WhileExecuting.new(item.dup, callback, redis_pool)
       end
     end
   end

data/lib/sidekiq_unique_jobs/lock/until_executed.rb

@@ -8,16 +8,28 @@ module SidekiqUniqueJobs
     #
     # @author Mikael Henriksson <mikael@mhenrixon.com>
     class UntilExecuted < BaseLock
-      OK = "OK"
+      #
+      # Locks a sidekiq job
+      #
+      # @note Will call a conflict strategy if lock can't be achieved.
+      #
+      # @return [String, nil] the locked jid when properly locked, else nil.
+      #
+      # @yield to the caller when given a block
+      #
+      def lock
+        return lock_failed(origin: :client) unless (token = locksmith.lock)
+        return yield token if block_given?
+
+        token
+      end
 
       # Executes in the Sidekiq server process
       # @yield to the worker class perform method
       def execute
-        lock do
+        locksmith.execute do
           yield
-          unlock_with_callback
-          callback_safely
-          item[JID]
+          unlock_and_callback
         end
       end
     end