sidekiq-unique-jobs 4.0.0 → 4.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9335a1bcf7592b094855e9d4562840691c9bcc96
-  data.tar.gz: bdd063a97f2a10c1844dda8c51b42221b50a52b6
+  metadata.gz: 5d354eaf8918e64ccbe7873ea1bc4a2f04392d78
+  data.tar.gz: 048516acc45e64d59f19e2f080b98d975a4b2d65
 SHA512:
-  metadata.gz: 2fd7ce95d41c91ec3155336cf7961e1d6986e92a261e8bde242ed2a720338abff103754c7973cad85d3a29b2f69d13234379877f64b466498ff904d86c6b0729
-  data.tar.gz: 7b3488a1eba8ff8b2457d5f70b1253dbdffff3bfca249cee54bf4f6a2673360ea3ce22b573c1297d5ee59959a430f9408e385f9cc4c6bb448966f0b16ef2b3fb
+  metadata.gz: 481a2053ca531710e228bf8d2da432f353c5f14af4f3d82f9748271ee190cf10ff9fcd1fb353bf16942fa56277cef5f31a0413d63ebdc657e653f56809533753
+  data.tar.gz: 104340d1f76fc29dab974c93afe7823ff673fa20a4349a819320fdb1f87916eba3b21f11d8484e8b1abaaca558500eca5a3296bc0fb56eb8b99669162822ed0b

data/.simplecov

@@ -1,6 +1,6 @@
 require 'simplecov-json'
 
-SimpleCov.refuse_coverage_drop
+# SimpleCov.refuse_coverage_drop
 SimpleCov.formatters = [
   SimpleCov::Formatter::HTMLFormatter,
   SimpleCov::Formatter::JSONFormatter

data/.travis.yml

@@ -10,7 +10,6 @@ rvm:
   - jruby-19mode
   - jruby-9.0.0.0
   - rbx-2
-  - 2.0.0
   - 2.1.7
   - 2.2.3
 env: STYLE=false
@@ -30,5 +29,5 @@ matrix:
   fast_finish: true
   include:
     - rvm: 2.2.3
-      gemfile: gemfiles/sidekiq_3.3.gemfile
+      gemfile: gemfiles/sidekiq_develop.gemfile
       env: STYLE=true

data/Appraisals

@@ -3,7 +3,7 @@ appraise 'sidekiq-develop' do
 end
 
 appraise 'sidekiq-2.17' do
-  gem 'sidekiq', '~> 2.17.0'
+  gem 'sidekiq', '~> 2.17.4'
 end
 
 appraise 'sidekiq-3.0' do

data/CHANGELOG.md

@@ -1,52 +1,95 @@
-## v3.0.16 (Unreleased)
+## v4.0.7
+
+- Use unique arguments for the `WhileExecuting` lock (#127)
+
+## v4.0.6
+
+- Removes enforced uniqueness for all jobs (#127)
+
+## v4.0.5
+
+- Forces look for `Sidekiq::Testing` in Sidekiq without ancestors #129
+
+## v4.0.4
+
+- Fix usage with active job
+- Get rid of unneeded configuration options `unique_args_enabled` (just use whatever unique argument that is configured).
+
+## v4.0.3
+
+- Remove `unique_lock` and use `unique: ` to set this like in `unique: :until_timeout`
+- Warn when using `unique: true` and suggest to change it to what we need with a fallback.
+- Create constants for hash keys to avoid having to fix spelling or for renaming keys only having to be done in one place and avoid having to type .freeze everywhere.
+- Move all explicit logic out from the server middle ware and make it just call execute on the instance of the lock class (prepare for allowing custom locking classes to be used).
+- Create a new job for scheduling jobs after it started executing but only allow one job to run at the same time.
+
+## v4.0.2
+
+- Fix a problem with an unresolved reference
+
+## v4.0.1
+
+- Get rid of development dependency on active support (causing trouble with jruby)
+
+## v4.0.0
 
 - Improved uniqueness handling (complete refactoring, upgrade with causion)
 - 100% breaking changes
 
 ## v3.0.15
+
 - Jobs only ever unlock themselves now (see #96 & #94 for info) thanks @pik
 - Slight refactoring and internal renaming. Shouldn't affect anyone
 - Run locks as an alternative when you only need to prevent the same job running twice but want to be able to schedule it multiple times. See #99 (thanks @pik)
 - Fixes #90, #92, #93, #97, #98, #100, #101, #105
 
 ## v3.0.14
+
 - Improve uniqueness check performance thanks @mpherham
 - Remove locks in sidekiq fake testing mode
 - Do not unlock jobs when sidekiq is shutting down 
 
 ## v3.0.13
+
 - Improved testing capabilities (testing uniqueness should not work better)
 - Configurable logging of duplicate payloads
 - Now requires `sidekiq_unique_ext` and `sidekiq/api` by default
 - Drop support for MRI 1.9 and sidekiq 2
 
 ## v3.0.11
+
 - Ensure threadsafety (thanks to adstage-david)
 
 ## v3.0.9
 - Fixed that all jobs stopped processing
 
 ## v3.0.8
+
 - Unique extensions for Web GUI by @rickenharp. Uniqueness will now be removed when a job is.
 
 ## v3.0.7
+
 - Internal refactoring
 - Improved coverage
 - Rubocop style validation
 
 ## v3.0.5
+
 - Fixed the different test modes (major thanks to @salrepe)
 
 ## v3.0.2
+
 - Removed runtime dependency on mock_redis (add `gem 'mock_redis'` to your desired group to use it)
 
 ## v2.7.0
+
 - Use mock_redis when testing in fake mode
 - Replace minitest with rspec
 - Add codeclimate badge
 - Update travis with redis-server
 
 ## v2.6.5
+
 - via @sax - possibility to set which arguments should be counted as unique - https://github.com/form26/sidekiq_unique_jobs/pull/12
 - via @eduardosasso - possibility to set which arguments should be counted as unique - https://github.com/form26/sidekiq_unique_jobs/pull/11
 - via @KensoDev - configuration of default expiration - https://github.com/form26/sidekiq_unique_jobs/pull/9

data/Gemfile

@@ -2,10 +2,9 @@ source 'http://rubygems.org'
 gemspec
 
 gem 'appraisal', '~> 2.0.0'
-
 gem 'rspec-its',     require: false
 
-platform :mri do
+platform :mri_22 do
   gem 'pry',                       require: false
   gem 'pry-rescue',                require: false
   gem 'pry-byebug',                require: false

data/README.md

@@ -1,4 +1,4 @@
-# SidekiqUniqueJobs [![Build Status](https://travis-ci.org/mhenrixon/sidekiq-unique-jobs.png?branch=master)](https://travis-ci.org/mhenrixon/sidekiq-unique-jobs) [![Code Climate](https://codeclimate.com/github/mhenrixon/sidekiq-unique-jobs.png)](https://codeclimate.com/github/mhenrixon/sidekiq-unique-jobs)
+# SidekiqUniqueJobs [![Build Status](https://travis-ci.org/mhenrixon/sidekiq-unique-jobs.png?branch=master)](https://travis-ci.org/mhenrixon/sidekiq-unique-jobs) [![Code Climate](https://codeclimate.com/github/mhenrixon/sidekiq-unique-jobs.png)](https://codeclimate.com/github/mhenrixon/sidekiq-unique-jobs) [![Test Coverage](https://codeclimate.com/github/mhenrixon/sidekiq-unique-jobs/badges/coverage.svg)](https://codeclimate.com/github/mhenrixon/sidekiq-unique-jobs/coverage)
 
 The missing unique jobs for sidekiq
 
@@ -6,12 +6,13 @@ The missing unique jobs for sidekiq
 
 See https://github.com/mperham/sidekiq#requirements for what is required. Starting from 3.0.13 only sidekiq 3 is supported and support for MRI 1.9 is dropped (it might work but won't be worked on)
 
-Version 4 requires redis 2.6.2!! Don't upgrade to version 4 unless you are on redis 2.6.2.
+### Version 4 Upgrade instructions
 
-## Upgrade instructions
+Version 4 requires redis >= 2.6.2!! Don't upgrade to version 4 unless you are on redis >= 2.6.2.
 
 Easy path - Drop all your unique jobs before upgrading the gem!
-Hard path - See above... Start with a clean slate :)
+
+Hard path - See below... Start with a clean slate :)
 
 ## Installation
 
@@ -35,20 +36,52 @@ To make things worse there are many ways of wanting to enforce uniqueness.
 
 ### While Executing
 
+Due to discoverability of the different lock types `unique` sidekiq option it was decided to use the `while_executing` as a default. Most people will note that scheduling any number of jobs with the same arguments is possible.
+
+```ruby
+sidekiq_options unique: :while_executing
+```
+
 Is to make sure that a job can be scheduled any number of times but only executed a single time per argument provided to the job we call this runtime uniqueness. This is probably most useful forbackground jobs that are fast to execute. (See mhenrixon/sidekiq-unique-jobs#111 for a great example of when this would be right.) While the job is executing/performing no other jobs can be executed at the same time.
 
 ### Until Executing
 
+```ruby
+sidekiq_options unique: :until_executing
+```
+
 This means that a job can only be scheduled into redis once per whatever the configuration of unique arguments. Any jobs added until the first one of the same arguments has been unlocked will just be dropped. This is what was tripping many people up. They would schedule a job to run in the future and it would be impossible to schedule new jobs with those same arguments even immediately. There was some forth and back between also locking jobs on the scheduled queue and the regular queues but in the end I decided it was best to separate these two features out into different locking mechanisms. I think what most people are after is to be able to lock a job while executing or that seems to be what people are most missing at the moment.
 
 ### Until Executed
 
+```ruby
+sidekiq_options unique: :until_executed
+```
+
 This is the combination of the two above. First we lock the job until it executes, then as the job begins executes we keep the lock so that no other jobs with the same arguments can execute at the same time.
 
 ### Until Timeout
 
+```ruby
+sidekiq_options unique: :until_timeout
+```
+
 The job won't be unlocked until the timeout/expiry runs out.
 
+### Unique Until And While Executing
+
+```ruby
+sidekiq_options unique: :until_and_while_executing
+```
+
+This lock is exactly what you would expect. It is considered unique in a way until executing begins and it is locked while executing so what differs from `UntilExecuted`? 
+
+The difference is that this job has two types of uniqueness:
+1. It is unique until execution
+2. It is unique while executing
+
+That means it locks for any job with the same arguments to be persisted into redis and just like you would expect it will only ever allow one job of the same unique arguments to run at any given time but as soon as the runtime lock has been aquired the schedule/async lock is released.
+
 ### Uniqueness Scope
 
 - Queue specific locks
@@ -57,10 +90,10 @@ The job won't be unlocked until the timeout/expiry runs out.
 
 ## Usage
 
-All that is required is that you specifically set the sidekiq option for *unique* to true like below:
+All that is required is that you specifically set the sidekiq option for *unique* to a valid value like below:
 
 ```ruby
-sidekiq_options unique: true
+sidekiq_options unique: :while_executing
 ```
 
 For jobs scheduled in the future it is possible to set for how long the job
@@ -68,12 +101,12 @@ should be unique. The job will be unique for the number of seconds configured (d
 or until the job has been completed. Thus, the job will be unique for the shorter of the two.  Note that Sidekiq versions before 3.0 will remove job keys after an hour, which means jobs can remain unique for at most an hour.
 
 *If you want the unique job to stick around even after it has been successfully
-processed then just set the unique_lock to anything except `:before_yield` or `:after_yield` (`unique_lock = :until_timeout`)
+processed then just set `unique: :until_timeout`.
 
 You can also control the expiration length of the uniqueness check. If you want to enforce uniqueness over a longer period than the default of 30 minutes then you can pass the number of seconds you want to use to the sidekiq options:
 
 ```ruby
-sidekiq_options unique: true, unique_expiration: 120 * 60 # 2 hours
+sidekiq_options unique: :until_timeout, unique_expiration: 120 * 60 # 2 hours
 ```
 
 Requiring the gem in your gemfile should be sufficient to enable unique jobs.
@@ -82,31 +115,24 @@ Requiring the gem in your gemfile should be sufficient to enable unique jobs.
 
 ```ruby
 Sidekiq.default_worker_options = {
-   'unique' => true,
-   'unique_args' => proc do |args|
-     [args.first.except('job_id')]
-   end
+  unique: :until_executing,
+  unique_args: ->(args) { args.first.except('job_id') }
 }
-SidekiqUniqueJobs.config.unique_args_enabled = true
 ```
 
 
 ### Finer Control over Uniqueness
 
-Sometimes it is desired to have a finer control over which arguments are used in determining uniqueness of the job, and others may be _transient_. For this use-case, you need to set `SidekiqUniqueJobs.config.unique_args_enabled` to true in an initializer, and then defined either `unique_args` method, or a ruby proc.
+Sometimes it is desired to have a finer control over which arguments are used in determining uniqueness of the job, and others may be _transient_. For this use-case, you need to define either a `unique_args` method, or a ruby proc.
 
 The unique_args method need to return an array of values to use for uniqueness check.
 
-```ruby
-SidekiqUniqueJobs.config.unique_args_enabled = true
-```
-
 The method or the proc can return a modified version of args without the transient arguments included, as shown below:
 
 ```ruby
 class UniqueJobWithFilterMethod
   include Sidekiq::Worker
-  sidekiq_options unique: true,
+  sidekiq_options unique: :until_and_during_execution,
                   unique_args: :unique_args
 
   def self.unique_args(name, id, options)
@@ -119,7 +145,7 @@ end
 
 class UniqueJobWithFilterProc
   include Sidekiq::Worker
-  sidekiq_options unique: true,
+  sidekiq_options unique: :until_executed,
                   unique_args: ->(args) { [ args.first ] }
 
   ...
@@ -127,22 +153,7 @@ class UniqueJobWithFilterProc
 end
 ```
 
-Note that objects passed into workers are converted to JSON *after* running through client middleware. In server middleware, the JSON is passed directly to the worker `#perform` method. So, you may run into issues where the arguments are different when enqueuing than they are when performing. Your `unique_args` method may need to account for this.
-
-### Unlock Ordering
-
-By default the server middleware will release the worker lock after yielding to the next middleware or worker. Alternatively, this can be changed by passing the `unique_lock` option:
-
-```ruby
-class UniqueJobWithFilterMethod
-  include Sidekiq::Worker
-  sidekiq_options unique: true,
-                  unique_locks: :until_executing
-
-  ...
-
-end
-```
+The previous problems with unique args being string in server and symbol in client is no longer a problem because the `UniqueArgs` class accounts for this and converts everything to json now. If you find an edge case please provide and example so that we can add coverage and fix it.
 
 ### After Unlock Callback
 
@@ -151,7 +162,7 @@ If you are using :after_yield as your unlock ordering, Unique Job offers a callb
 ```ruby
 class UniqueJobWithFilterMethod
   include Sidekiq::Worker
-  sidekiq_options unique: true,
+  sidekiq_options unique: :while_executing,
 
   def after_unlock
    # block has yielded and lock is released
@@ -161,17 +172,6 @@ end.
 
 ```
 
-### Unique Storage Method
-
-Starting from sidekiq-unique-jobs 3.0.14 we will use the `set` method in a way that has been available since redis 2.6.12. If you are on an older redis version you will have to change a config value like below.
-
-```ruby
-SidekiqUniqueJobs.config.unique_storage_method = :old
-```
-
-That should allow you to keep using redis in the old fashion way. See #89 for mor information.
-
-
 ### 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
@@ -179,7 +179,7 @@ To see logging in sidekiq when duplicate payload has been filtered out you can e
 ```ruby
 class UniqueJobWithFilterMethod
   include Sidekiq::Worker
-  sidekiq_options unique: true,
+  sidekiq_options unique: :while_executing,
                   log_duplicate_payload: true
 
   ...
@@ -191,8 +191,6 @@ end
 
 To enable the testing for `sidekiq-unique-jobs`, add `require 'sidekiq_unique_jobs/testing'` to your testing helper.
 
-SidekiqUniqueJobs uses mock_redis for inline testing. Due to complaints about having that as a runtime dependency it was made a development dependency so if you are relying on inline testing you will have to add `gem 'mock_redis'` to your Gemfile.
-
 ## Contributing
 
 1. Fork it

data/circle.yml

@@ -1,5 +1,7 @@
 machine:
-  ruby: 2.2.3
+  ruby:
+    version:
+      2.2.3
   java:
     version: oraclejdk8
   environment:

data/gemfiles/sidekiq_2.17.gemfile

@@ -3,13 +3,15 @@
 source "http://rubygems.org"
 
 gem "appraisal", "~> 2.0.0"
-gem "sidekiq", "~> 2.17.0"
+gem "rspec-its", :require => false
+gem "sidekiq", "~> 2.17.4"
 
-platforms :mri do
-  gem "pry-suite", :require => false
-  gem "let_it_go", :require => false
-  gem "memory-profiler", :require => false
+platforms :mri_22 do
+  gem "pry", :require => false
+  gem "pry-rescue", :require => false
+  gem "pry-byebug", :require => false
   gem "simplecov-json", :require => false
+  gem "memory_profiler", :require => false
   gem "codeclimate-test-reporter", :require => false
 end
 

data/gemfiles/sidekiq_3.0.gemfile

@@ -3,13 +3,15 @@
 source "http://rubygems.org"
 
 gem "appraisal", "~> 2.0.0"
+gem "rspec-its", :require => false
 gem "sidekiq", "~> 3.0.0"
 
-platforms :mri do
-  gem "pry-suite", :require => false
-  gem "let_it_go", :require => false
-  gem "memory-profiler", :require => false
+platforms :mri_22 do
+  gem "pry", :require => false
+  gem "pry-rescue", :require => false
+  gem "pry-byebug", :require => false
   gem "simplecov-json", :require => false
+  gem "memory_profiler", :require => false
   gem "codeclimate-test-reporter", :require => false
 end
 

data/gemfiles/sidekiq_3.1.gemfile

@@ -3,13 +3,15 @@
 source "http://rubygems.org"
 
 gem "appraisal", "~> 2.0.0"
+gem "rspec-its", :require => false
 gem "sidekiq", "~> 3.1.0"
 
-platforms :mri do
-  gem "pry-suite", :require => false
-  gem "let_it_go", :require => false
-  gem "memory-profiler", :require => false
+platforms :mri_22 do
+  gem "pry", :require => false
+  gem "pry-rescue", :require => false
+  gem "pry-byebug", :require => false
   gem "simplecov-json", :require => false
+  gem "memory_profiler", :require => false
   gem "codeclimate-test-reporter", :require => false
 end
 

data/gemfiles/sidekiq_3.2.gemfile

@@ -3,13 +3,15 @@
 source "http://rubygems.org"
 
 gem "appraisal", "~> 2.0.0"
+gem "rspec-its", :require => false
 gem "sidekiq", "~> 3.2.0"
 
-platforms :mri do
-  gem "pry-suite", :require => false
-  gem "let_it_go", :require => false
-  gem "memory-profiler", :require => false
+platforms :mri_22 do
+  gem "pry", :require => false
+  gem "pry-rescue", :require => false
+  gem "pry-byebug", :require => false
   gem "simplecov-json", :require => false
+  gem "memory_profiler", :require => false
   gem "codeclimate-test-reporter", :require => false
 end