sidekiq-lock 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9c3099623c0436cfe8cbd6eb0d3f56168ac0fda088b7167a0211ca4cba6e530
-  data.tar.gz: b5105d14dd29c9374b43a46cba4cfd6c576f086808051949bf4729c9163be05e
+  metadata.gz: 1ffe149da064b8eb553518599979c7849039f092ced6b84189ff18fc58cc97ab
+  data.tar.gz: 830545455288f3f6ff5b2246670f81f6ca46bc67aaff5260ddb1c01e6910cf84
 SHA512:
-  metadata.gz: 18898eaacf8fd60adeee2dce1e53e96bf517878856541220cbb472338dd7e4f531463917fb059b0767bb411834fe42f23aac535cb078f814de76de4bda8c3bfc
-  data.tar.gz: 07ee42bde63d54ef88ad56625167f781b259943967507fefe4769735377f12fd12dbf28985b3c0a4cf5d4a950a3162367bdcc78ce17f5ff346003c22ff38ecab
+  metadata.gz: 968ed503ca7b88e5d317c79193d21452b4390049cf4650319d6f13621a2c9d73feab068743564ff0e48f9b3770e89dbace35b6b46e8b0b650f19950a587e46f0
+  data.tar.gz: c947c37e1a96bc9a9160b8d7e0df7cb8c44f39a94ebb34140b9a35c6c5434c54de0e3377e042cc8af9d7305b9bad7948bea8d4d9e33c74ec5c75531d09ac01d0

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 0.8.0 (September 1, 2026)
+
+**NOTE:** Original author no longer uses this gem in production; changes are mostly: long-term maintenance, modern Sidekiq support and some edge cases handlers; if you noticed some breakage please do file an issue!
+
+- added support for Sidekiq 8 and Ruby 3.1-3.5
+- freeze all strings (performance)
+- dropped support for Ruby versions older than 3.1
+- clear the current lock before and after each middleware invocation, including when a worker raises
+- validate that lock names are not empty and lock timeouts are positive integers
+- prevent a lock instance that did not acquire a lock from releasing it
+- fixed lock release when Redis has flushed its script cache
+- updated inline testing guidance and corrected custom lock configuration examples
+
 ## 0.7.0 (Feb 7, 2024)
 
 - support for Sidekiq 7.2 (thanks for the issue report [9mm](https://github.com/9mm))

data/README.md

@@ -1,11 +1,12 @@
 <p align="center">
-  <img width="300" height="210" src="https://github.com/rwojsznis/sidekiq-lock/raw/main/logo.png">
+  <img width="600" height="200" alt="sidekiq-lock" src="https://github.com/user-attachments/assets/443421d3-f508-464d-a505-d2ca6f18e21b" />
 </p>
 
 # Sidekiq::Lock
 
-[![Code Climate](https://codeclimate.com/github/rwojsznis/sidekiq-lock.png)](https://codeclimate.com/github/rwojsznis/sidekiq-lock)
-[![Gem Version](https://badge.fury.io/rb/sidekiq-lock.png)](http://badge.fury.io/rb/sidekiq-lock)
+
+[![GitHub Release](https://img.shields.io/github/v/release/rwojsznis/sidekiq-lock)](https://github.com/rwojsznis/sidekiq-lock/releases/latest)
+[![CI](https://github.com/rwojsznis/sidekiq-lock/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/rwojsznis/sidekiq-lock/actions/workflows/test.yml?query=branch%3Amain)
 
 **Note:** This is a _complete_ piece of software, it should work across all future sidekiq & ruby versions.
 
@@ -98,9 +99,7 @@ class Worker
         # I can do the work
         # ...
       ensure
-        # You probably want to manually release lock after work is done
-        # This method can be safely called even if lock wasn't acquired
-        # by current worker (thread). For more references see RedisLock class
+        # You probably want to manually release the lock after work is done.
         lock.release!
       end
     else
@@ -114,18 +113,16 @@ Just be sure to provide valid redis key as a lock name.
 
 ### Customizing lock method name
 
-You can change `lock` to something else (globally) in sidekiq server configuration:
+You can change `lock` to something else globally before starting Sidekiq:
 
 ``` ruby
-Sidekiq.configure_server do |config|
-  config.lock_method = :redis_lock
-end
+Sidekiq.lock_method = :redis_lock
 ```
 
 ### Customizing lock _container_
 
 If you would like to change default behavior of storing lock instance in `Thread.current` for whatever reason you
-can do that as well via server configuration:
+can do that as well before starting Sidekiq:
 
 ``` ruby
 # Any thread-safe class that implements .fetch and .store methods will do
@@ -139,15 +136,23 @@ class CustomStorage
   end
 end
 
-Sidekiq.configure_server do |config|
-  config.lock_container = CustomStorage.new
-end
+Sidekiq.lock_container = CustomStorage.new
 ```
 
 ### Inline testing
 
-As you know middleware is not invoked when testing jobs inline, you can require in your test/spec helper file
-`sidekiq/lock/testing/inline` to include two methods that will help you setting / clearing up lock manually:
+`perform_inline` invokes Sidekiq's normal server middleware chain. `Sidekiq::Testing.inline!`, however, uses a
+separate testing middleware chain. Add the lock middleware to that chain if you want inline jobs to behave like
+production jobs:
+
+``` ruby
+Sidekiq::Testing.server_middleware do |chain|
+  chain.add Sidekiq::Lock::Middleware
+end
+```
+
+For tests that call `perform` directly, require `sidekiq/lock/testing/inline` in your test/spec helper to make these
+manual setup and cleanup methods available:
 
 - `set_sidekiq_lock(worker_class, payload)` - note: payload should be an array of worker arguments
 - `clear_sidekiq_lock`

data/Rakefile

@@ -1,6 +1,10 @@
 #!/usr/bin/env rake
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
+require "fileutils"
 require "rake/testtask"
+require_relative "lib/sidekiq/lock/version"
 
 task :default => :test
 
@@ -10,3 +14,26 @@ Rake::TestTask.new do |t|
   t.test_files = FileList["test/**/*_test.rb"]
   t.verbose = true
 end
+
+namespace :release do
+  desc "Validate the changelog entry for the current version"
+  task :check do
+    version = Sidekiq::Lock::VERSION
+    changelog = File.read("CHANGELOG.md")
+    heading = /^## #{Regexp.escape(version)} \([^)]+\)$/
+    entry = changelog.match(/#{heading.source}\n+(.*?)(?=^## |\z)/m)
+
+    abort "CHANGELOG.md has no entry for version #{version}" unless entry
+    abort "CHANGELOG.md entry for version #{version} is empty" if entry[1].strip.empty?
+  end
+
+  desc "Write GitHub release notes from the current changelog entry"
+  task notes: :check do
+    version = Sidekiq::Lock::VERSION
+    changelog = File.read("CHANGELOG.md")
+    entry = changelog.match(/^## #{Regexp.escape(version)} \([^)]+\)\n+(.*?)(?=^## |\z)/m)
+
+    FileUtils.mkdir_p("pkg")
+    File.write("pkg/release-notes.md", "#{entry[1].strip}\n")
+  end
+end

data/lib/sidekiq/lock/container.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Lock
     class Container

data/lib/sidekiq/lock/middleware.rb

@@ -1,11 +1,16 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Lock
     class Middleware
       def call(worker, msg, _queue)
         options = lock_options(worker)
+        Sidekiq.lock_container.store(nil)
         setup_lock(options, msg['args']) unless options.nil?
 
         yield
+      ensure
+        Sidekiq.lock_container.store(nil)
       end
 
       private

data/lib/sidekiq/lock/redis_lock.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+require 'securerandom'
+
 module Sidekiq
   module Lock
     class RedisLock
@@ -32,6 +37,8 @@ module Sidekiq
       end
 
       def release!
+        return false unless acquired?
+
         # even if lock expired / was take over by another process
         # it still means from our perspective that we released it
         @acquired = false
@@ -43,13 +50,26 @@ module Sidekiq
       def name
         raise ArgumentError, 'Provide a lock name inside sidekiq_options' if options[:name].nil?
 
-        @name ||= (options[:name].respond_to?(:call) ? options[:name].call(*payload) : options[:name])
+        @name ||= begin
+          name = options[:name].respond_to?(:call) ? options[:name].call(*payload) : options[:name]
+          raise ArgumentError, 'Lock name must not be empty' if name.nil? || name.to_s.empty?
+
+          name
+        end
       end
 
       def timeout
         raise ArgumentError, 'Provide lock timeout inside sidekiq_options' if options[:timeout].nil?
 
-        @timeout ||= (options[:timeout].respond_to?(:call) ? options[:timeout].call(*payload) : options[:timeout]).to_i
+        @timeout ||= begin
+          timeout = options[:timeout].respond_to?(:call) ? options[:timeout].call(*payload) : options[:timeout]
+          timeout = Integer(timeout)
+          raise ArgumentError, 'Lock timeout must be positive' unless timeout.positive?
+
+          timeout
+        rescue TypeError, ArgumentError
+          raise ArgumentError, 'Lock timeout must be a positive integer'
+        end
       end
 
       private
@@ -63,7 +83,7 @@ module Sidekiq
             begin
               r.evalsha redis_lock_script_sha, [name], [value]
             rescue RedisClient::CommandError
-              r.eval redis_lock_script, 1, [name], [value]
+              r.call('EVAL', redis_lock_script, 1, name, value)
             end
           end
         else

data/lib/sidekiq/lock/testing/inline.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 def set_sidekiq_lock(worker_class, payload)
   options = worker_class.get_sidekiq_options['lock']
   Sidekiq.lock_container.store(Sidekiq::Lock::RedisLock.new(options, payload))

data/lib/sidekiq/lock/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Lock
-    VERSION = '0.7.0'
+    VERSION = '0.8.0'
   end
 end

data/lib/sidekiq/lock/worker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Lock
     module Worker

data/lib/sidekiq/lock.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sidekiq/lock/container'
 require 'sidekiq/lock/middleware'
 require 'sidekiq/lock/redis_lock'

data/lib/sidekiq-lock.rb

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

data/test/lib/container_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'open3'
 

data/test/lib/lock_test.rb

@@ -1,30 +1,27 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'open3'
 
 module Sidekiq
   describe Lock do
     it 'automatically loads lock middleware for sidekiq server' do
-      skip 'Sidekiq 7+ does not print out middleware information' if Sidekiq::VERSION >= '7'
+      script = <<~'RUBY'
+        require 'sidekiq/cli'
+        require 'sidekiq-lock'
 
-      cmd = 'sidekiq -r ./test/test_workers.rb -v'
-      buffer_out = ''
+        chain = if Sidekiq.respond_to?(:default_configuration)
+          Sidekiq.default_configuration.server_middleware
+        else
+          Sidekiq.server_middleware
+        end
 
-      # very not fancy (https://78.media.tumblr.com/tumblr_lzkpw7DAl21qhy6c9o2_400.gif)
-      # solution, but should do the job
-      Open3.popen3(cmd) do |stdin, stdout, stderr, thread|
-        begin
-          Timeout.timeout(3) do
-            until stdout.eof? do
-              buffer_out << stdout.read_nonblock(16)
-            end
-          end
+        abort 'lock middleware was not registered' unless chain.exists?(Sidekiq::Lock::Middleware)
+      RUBY
 
-        rescue Timeout::Error
-          Process.kill('KILL', thread.pid)
-        end
-      end
+      _stdout, stderr, status = Open3.capture3(Gem.ruby, '-Ilib', '-e', script)
 
-      assert_match(/\s?Middleware:.*Sidekiq::Lock::Middleware/i, buffer_out)
+      assert status.success?, stderr
     end
   end
 end

data/test/lib/middleware_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module Sidekiq
@@ -18,20 +20,20 @@ module Sidekiq
       it 'sets lock variable with provided static lock options' do
         handler = Sidekiq::Lock::Middleware.new
         handler.call(LockWorker.new, { 'class' => LockWorker, 'args' => [] }, 'default') do
-          true
+          assert_kind_of RedisLock, lock_container_variable
         end
 
-        assert_kind_of RedisLock, lock_container_variable
+        assert_nil lock_container_variable
       end
 
       it 'sets lock variable with provided dynamic options' do
         handler = Sidekiq::Lock::Middleware.new
         handler.call(DynamicLockWorker.new, { 'class' => DynamicLockWorker, 'args' => [1234, 1000] }, 'default') do
-          true
+          assert_equal "lock:1234", lock_container_variable.name
+          assert_equal 2000, lock_container_variable.timeout
         end
 
-        assert_equal "lock:1234", lock_container_variable.name
-        assert_equal 2000, lock_container_variable.timeout
+        assert_nil lock_container_variable
       end
 
       it 'sets nothing for workers without lock options' do
@@ -42,6 +44,27 @@ module Sidekiq
 
         assert_nil lock_container_variable
       end
+
+      it 'clears a previous lock before running a worker without lock options' do
+        handler = Sidekiq::Lock::Middleware.new
+        set_lock_variable!(RedisLock.new({ 'timeout' => 500, 'name' => 'old-lock' }, []))
+
+        handler.call(RegularWorker.new, { 'class' => RegularWorker, 'args' => [] }, 'default') do
+          assert_nil lock_container_variable
+        end
+      end
+
+      it 'clears the lock when a worker raises' do
+        handler = Sidekiq::Lock::Middleware.new
+
+        assert_raises RuntimeError do
+          handler.call(LockWorker.new, { 'class' => LockWorker, 'args' => [] }, 'default') do
+            raise 'worker failed'
+          end
+        end
+
+        assert_nil lock_container_variable
+      end
     end
   end
 end

data/test/lib/redis_lock_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module Sidekiq
@@ -36,6 +38,28 @@ module Sidekiq
         assert RedisLock.new({ 'timeout' => 500, 'name' => 'lock-name' }, [])
       end
 
+      it "rejects an empty evaluated name" do
+        error = assert_raises ArgumentError do
+          RedisLock.new({ 'timeout' => 500, 'name' => proc { nil } }, [])
+        end
+
+        assert_equal 'Lock name must not be empty', error.message
+      end
+
+      it "rejects invalid evaluated timeouts" do
+        [nil, 'invalid', 0, -1].each do |timeout|
+          assert_raises ArgumentError do
+            RedisLock.new({ 'timeout' => proc { timeout }, 'name' => 'lock-name' }, [])
+          end
+        end
+      end
+
+      it "accepts a positive integer timeout encoded as a string" do
+        lock = RedisLock.new({ 'timeout' => '500', 'name' => 'lock-name' }, [])
+
+        assert_equal 500, lock.timeout
+      end
+
       it "is released by default" do
         lock = RedisLock.new({ 'timeout' => 500, 'name' => 'lock-name' }, [])
         refute lock.acquired?
@@ -60,18 +84,18 @@ module Sidekiq
         assert lock.acquire!
       end
 
-      it "sets proper lock value on first and second acquire" do
+      it "releases a lock after Redis flushes its script cache" do
         lock = RedisLock.new({'timeout' => 1000, 'name' => 'test-lock', 'value' => 'lock value'}, [])
         assert lock.acquire!
         assert_equal 'lock value', redis("get", lock.name)
         assert lock.release!
-        # at this point script should be used from evalsha
-        assert lock.acquire!
-        assert_equal 'lock value', redis("get", lock.name)
 
-        redis("script", "flush")
         assert lock.acquire!
         assert_equal 'lock value', redis("get", lock.name)
+        redis("script", "flush")
+
+        assert lock.release!
+        assert_nil redis("get", lock.name)
       end
 
       it "cannot acquire lock if it's already taken by other process/thread" do
@@ -82,6 +106,15 @@ module Sidekiq
         refute slower_lock.acquire!
       end
 
+      it "does not release a lock that this instance did not acquire" do
+        acquired_lock = RedisLock.new({'timeout' => 1000, 'name' => 'test-lock', 'value' => 'shared'}, [])
+        unacquired_lock = RedisLock.new({'timeout' => 1000, 'name' => 'test-lock', 'value' => 'shared'}, [])
+        assert acquired_lock.acquire!
+
+        refute unacquired_lock.release!
+        assert_equal 'shared', redis('get', 'test-lock')
+      end
+
       it "releases taken lock" do
         lock = RedisLock.new({'timeout' => 100, 'name' => 'test-lock'}, [])
         lock.acquire!

data/test/lib/testing/inline_test.rb

@@ -1,24 +1,74 @@
+# frozen_string_literal: true
+
 require "test_helper"
 require "sidekiq/lock/testing/inline"
 
+if Sidekiq.respond_to?(:testing!)
+  Sidekiq.testing!(:fake)
+else
+  require "sidekiq/testing"
+end
+
 describe "inline test helper" do
   after { reset_lock_variable! }
 
-  it "has helper fuction for setting lock" do
-    Sidekiq::Lock::RedisLock
-      .expects(:new)
-      .with({ timeout: 1, name: 'lock-worker' }, 'worker argument')
-      .returns('lock set')
+  it "has helper function for setting lock" do
+    set_sidekiq_lock(LockWorker, ['worker argument'])
 
-    set_sidekiq_lock(LockWorker, 'worker argument')
-    assert_equal 'lock set', lock_container_variable
+    assert_kind_of Sidekiq::Lock::RedisLock, lock_container_variable
+    assert_equal 'lock-worker', lock_container_variable.name
+    assert_equal 1, lock_container_variable.timeout
   end
 
-  it "has helper fuction for clearing lock" do
+  it "provides a manually configured lock to a directly executed worker" do
+    set_sidekiq_lock(InlineLockWorker, ['manual'])
+
+    InlineLockWorker.new.perform('manual')
+
+    assert_equal ['inline-lock-manual', 1000], InlineLockWorker.observed_lock
+  ensure
+    InlineLockWorker.observed_lock = nil
+  end
+
+  it "has helper function for clearing lock" do
     set_lock_variable! "test"
     assert_equal "test", lock_container_variable
 
     clear_sidekiq_lock
     assert_nil lock_container_variable
   end
+
+  it "provides the lock during perform_inline" do
+    skip 'perform_inline is unavailable in this Sidekiq version' unless InlineLockWorker.respond_to?(:perform_inline)
+
+    chain = Sidekiq.default_configuration.server_middleware
+    middleware_added = !chain.exists?(Sidekiq::Lock::Middleware)
+    chain.add Sidekiq::Lock::Middleware if middleware_added
+
+    InlineLockWorker.perform_inline('direct')
+
+    assert_equal ['inline-lock-direct', 1000], InlineLockWorker.observed_lock
+    assert_nil lock_container_variable
+  ensure
+    chain&.remove(Sidekiq::Lock::Middleware) if middleware_added
+    InlineLockWorker.observed_lock = nil
+  end
+
+  it "provides the lock during Sidekiq testing inline execution" do
+    Sidekiq::Testing.server_middleware do |chain|
+      chain.add Sidekiq::Lock::Middleware unless chain.exists?(Sidekiq::Lock::Middleware)
+    end
+
+    Sidekiq::Testing.inline! do
+      InlineLockWorker.perform_async('testing')
+    end
+
+    assert_equal ['inline-lock-testing', 1000], InlineLockWorker.observed_lock
+    assert_nil lock_container_variable
+  ensure
+    Sidekiq::Testing.server_middleware do |chain|
+      chain.remove(Sidekiq::Lock::Middleware)
+    end
+    InlineLockWorker.observed_lock = nil
+  end
 end

data/test/lib/worker_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module Sidekiq

data/test/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'mocha/minitest'
 require 'sidekiq'

data/test/test_workers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 require 'sidekiq-lock'
 
@@ -20,3 +22,17 @@ class RegularWorker
   include Sidekiq::Worker
   include Sidekiq::Lock::Worker
 end
+
+class InlineLockWorker
+  include Sidekiq::Worker
+  include Sidekiq::Lock::Worker
+  sidekiq_options lock: { timeout: 1000, name: proc { |argument| "inline-lock-#{argument}" } }
+
+  class << self
+    attr_accessor :observed_lock
+  end
+
+  def perform(argument)
+    self.class.observed_lock = [lock.name, lock.timeout]
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-lock
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Rafal Wojsznis
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -51,11 +50,14 @@ files:
 - test/lib/worker_test.rb
 - test/test_helper.rb
 - test/test_workers.rb
-homepage: https://github.com/emq/sidekiq-lock
+homepage: https://github.com/rwojsznis/sidekiq-lock
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  bug_tracker_uri: https://github.com/rwojsznis/sidekiq-lock/issues
+  changelog_uri: https://github.com/rwojsznis/sidekiq-lock/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/rwojsznis/sidekiq-lock
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -63,15 +65,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Simple redis-based lock mechanism for your sidekiq workers
 test_files: