sidekiq-debouncer 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f505c753200cb5a607d4a0f847372a72f5f5571631d6b50e12348e99b407f30
-  data.tar.gz: b72d1d31b9b1b13a7ab8ec88a56a27e2a84e11a8dca721e296ec4a25da361dd7
+  metadata.gz: 939e5397d600c7f5f24b3757f46f0c613369079ef327c8e88bf5adcdf807733f
+  data.tar.gz: 6ee4f636b9297a232a82bcf6c27c1418408cd2ad66ad8e473945fd1fdbc12cb0
 SHA512:
-  metadata.gz: 400505251465ceca2630d226a8f1017518a5bb068e755a05428e8f00be81519c2ddcda91be840c24f3eaf382ff7302e1c1941fe790eec95a5cb9f9d9f72dd797
-  data.tar.gz: 6d01faab4b9f4b98512dadb598100674d241ab3fd99a324e1abb89773a9a4c92ba8782fb1564e68a97d4c171646ec9f6472a25cdb507eba218d739f368f1226f
+  metadata.gz: 3b84978f7ea580d81a052719860ef38fc10339d35064c768457ffcccf0effb7dd148a2bd7a6620489a68c5a03705aea400f2ce8f493e2d0e27fa48edcb806082
+  data.tar.gz: f0e2d36120e11883f9b2f29b4de2f4fcbfbae075c72592742b9b6a3f323458a0bf7222fb4853604df45c1755e15ead8b600024630bd976631d3df4b5679f996a

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## [2.0.0] - 2023-02-28
+Complete rewrite of the library:  
+- Instead of iterating through whole schedule set, sidekiq-debouncer will now cache debounce key in redis with a reference to the job.
+Thanks to that there is a huge performance boost compared to V1. With 1k jobs in schedule set it's over 100x faster.
+The difference is even bigger with larger amount of jobs.
+- Debouncing is now handled by Lua script instead of pure ruby so it's process safe.
+
+Breaking changes:
+- Including `Sidekiq::Debouncer` in the workers and using `debounce` method is now deprecated. Use `perform_async` instead.
+- Setup requires middlewares to be added in sidekiq configuration.
+- `by` attribute is now required
+- dropped support for Ruby < 2.7 and Sidekiq < 6.5

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Gabriel Evans
+Copyright (c) 2023 Karol Bąk
 
 MIT License
 
@@ -19,4 +19,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -2,7 +2,9 @@
 
 Sidekiq extension that adds the ability to debounce job execution.
 
-Worker will postpone its execution after `wait time` have elapsed since the last time it was invoked. Useful for implementing behavior that should only happen after the input has stopped arriving. For example: sending group email to the user after he stopped interacting with the application.
+Worker will postpone its execution after `wait time` have elapsed since the last time it was invoked. 
+Useful for implementing behavior that should only happen after the input has stopped arriving. 
+For example: sending one email with multiple notifications.
 
 ## Installation
 
@@ -18,39 +20,35 @@ And then execute:
 
 ## Basic usage
 
-In a worker, include `Sidekiq::Debouncer` module, specify debounce wait time (in seconds):
+Add middlewares to sidekiq:
 
 ```ruby
-class MyWorker
-  include Sidekiq::Worker
-  include Sidekiq::Debouncer
-
-  sidekiq_options(
-    debounce: {
-      time: 5 * 60
-    }
-  )
+Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add Sidekiq::Debouncer::Middleware::Client
+  end
+end
 
-  def perform(group)
-    group.each do
-      # do some work with group
-    end
+Sidekiq.configure_server do |config|
+  config.client_middleware do |chain|
+    chain.add Sidekiq::Debouncer::Middleware::Client
+  end
+  
+  config.server_middleware do |chain|
+    chain.add Sidekiq::Debouncer::Middleware::Server
   end
 end
 ```
 
-You can specify your own debounce method. In this case worker will be debounced if first argument matches.
+Add debounce option to worker with `by` and `time` keys:
 ```ruby
 class MyWorker
   include Sidekiq::Worker
-  include Sidekiq::Debouncer
 
   sidekiq_options(
     debounce: {
-      time: 5 * 60,
-      by: -> (job_args) {
-        job_args[0]
-      }
+      by: -> (args) { args[0] }, # debounce by first argument only
+      time: 5 * 60
     }
   )
 
@@ -62,11 +60,10 @@ class MyWorker
 end
 ```
 
-You can also pass symbol as `debounce_by` matching class method.
+You can also pass symbol as `debounce.by` matching class method.
 ```ruby
 class MyWorker
   include Sidekiq::Worker
-  include Sidekiq::Debouncer
 
   sidekiq_options(
     debounce: {
@@ -87,9 +84,29 @@ class MyWorker
 end
 ```
 
+Keep in mind that the result of the debounce method will be converted to string, so make sure it doesn't return any objects that don't implement `to_s` method.
+
+In the application, call `MyWorker.perform_async(...)` as usual. Everytime you call this function, `MyWorker`'s execution will be postponed by 5 minutes. After that time `MyWorker` will receive a method call `perform` with an array of arguments that were provided to the `MyWorker.perform_async(...)` calls.
+
+To avoid keeping leftover keys in redis (for example, when job was manually removed from schedule set), all additional keys are created with TTL.
+It's 7 days by default and should be ok in most of the cases. If you are debouncing your jobs in higher interval than that, you can overwrite this setting:
+
+```ruby
+Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add Sidekiq::Debouncer::Middleware::Client, ttl: 60 * 60 * 24 * 30 # 30 days
+  end
+end
+```
+
+## Testing
 
-In the application, call `MyWorker.debounce(...)`. Everytime you call this function, `MyWorker`'s execution will be postponed by 5 minutes. After that time `MyWorker` will receive a method call `perform` with an array of arguments that were provided to the `MyWorker.debounce(...)`.
+In order to test the behavior of `sidekiq-debouncer` it is necessary to disable testing mode. It is the limitation of internal implementation.
 
 ## License
 
 MIT Licensed. See LICENSE.txt for details.
+
+## Notes
+
+This gem was renamed from `sidekiq-debouce` due to name conflict on rubygems.

data/lib/sidekiq/debouncer/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Debouncer
+    Error = Class.new(StandardError)
+    NotSupportedError = Class.new(Error)
+    MissingArgumentError = Class.new(Error)
+  end
+end

data/lib/sidekiq/debouncer/lua/debounce.lua

@@ -0,0 +1,22 @@
+local set = KEYS[1]
+local debounce_key = KEYS[2]
+
+local job = ARGV[1]
+local time = ARGV[2]
+local ttl = ARGV[3]
+
+local existing_debounce = redis.call("GET", debounce_key)
+
+if existing_debounce then
+    redis.call("DEL", debounce_key)
+    -- skip if job wasn't found in schedule set
+    if redis.call("ZREM", set, existing_debounce) > 0 then
+        local new_args = cjson.decode(job)['args'][1]
+        local new_job = cjson.decode(existing_debounce)
+        table.insert(new_job['args'], new_args)
+        job = cjson.encode(new_job)
+    end
+end
+
+redis.call("SET", debounce_key, job, "EX", ttl)
+redis.call("ZADD", set, time, job)

data/lib/sidekiq/debouncer/middleware/client.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module Sidekiq
+  module Debouncer
+    module Middleware
+      # Middleware used to debounce jobs. If a job has a debounce option it skips normal sidekiq flow and debounces
+      # job using lua script (thanks to that it's process safe). Script merges new job with existing one and creates
+      # debounce key in redis with a reference to the job placed in schedule set. Reference is used to remove existing
+      # job from schedule set when another debounce occurs.
+      class Client
+        include Sidekiq::ClientMiddleware
+
+        LUA_DEBOUNCE = File.read(File.expand_path("../../lua/debounce.lua", __FILE__))
+        LUA_DEBOUNCE_SHA = Digest::SHA1.hexdigest(LUA_DEBOUNCE)
+        REDIS_ERROR_CLASS = defined?(RedisClient::CommandError) ? RedisClient::CommandError : Redis::CommandError
+
+        def initialize(options = {})
+          @debounce_key_ttl = options.fetch(:ttl, 60 * 60 * 24 * 7) # 7 days by default
+        end
+
+        def call(worker_class, job, _queue, _redis_pool)
+          klass = worker_class.is_a?(String) ? Object.const_get(worker_class) : worker_class
+
+          yield # call the rest of middleware stack
+          # skip if debounce options not set or client middleware is included in server
+          return job if !klass.get_sidekiq_options["debounce"] || job["debounce_key"]
+
+          debounce(klass, job)
+
+          # prevent normal sidekiq flow
+          false
+        end
+
+        private
+
+        def debounce(klass, job)
+          raise NotSupportedError, "perform_at is not supported with debounce" if job.key?("at")
+
+          options = debounce_options(klass)
+          key = debounce_key(klass, job, options)
+          time = (options[:time].to_f + Time.now.to_f).to_s
+
+          job["debounce_key"] = key
+          job["args"] = [job["args"]]
+          job.delete("debounce")
+
+          redis do |connection|
+            redis_debounce(connection, keys: ["schedule", key], argv: [Sidekiq.dump_json(job), time, @debounce_key_ttl])
+          end
+        end
+
+        def debounce_key(klass, job, options)
+          method = options[:by]
+          result = method.is_a?(Symbol) ? klass.send(method, job["args"]) : method.call(job["args"])
+          "debounce/#{klass.name}/#{result}"
+        end
+
+        def debounce_options(klass)
+          options = klass.get_sidekiq_options["debounce"].transform_keys(&:to_sym)
+
+          raise MissingArgumentError, "'by' attribute not provided" unless options[:by]
+          raise MissingArgumentError, "'time' attribute not provided" unless options[:time]
+
+          options
+        end
+
+        def redis_debounce(connection, keys:, argv:)
+          retryable = true
+          begin
+            connection.call("EVALSHA", LUA_DEBOUNCE_SHA, keys.size, *keys, *argv)
+          rescue REDIS_ERROR_CLASS => e
+            raise if !e.message.start_with?("NOSCRIPT") || !retryable
+
+            # upload script to redis cache and retry
+            connection.call("SCRIPT", "LOAD", LUA_DEBOUNCE)
+            retryable = false
+            retry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/debouncer/middleware/server.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Debouncer
+    module Middleware
+      # Server middleware removes debounce key from redis before executing the job
+      class Server
+        include Sidekiq::ServerMiddleware
+
+        def call(_worker, job, _queue)
+          if job.key?("debounce_key")
+            # skip if job comes from dead or retry set
+            unless job.key?("failed_at")
+              redis do |connection|
+                connection.call("DEL", job["debounce_key"])
+              end
+            end
+
+            job["args"] = [job["args"]] # wrap args into array because sidekiq uses splat while calling perform
+          end
+
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/debouncer/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Debouncer
-    VERSION = '1.0.1'.freeze
+    VERSION = "2.0.0"
   end
 end

data/lib/sidekiq/debouncer.rb

@@ -1,7 +1,9 @@
-require 'sidekiq'
-require 'sidekiq/api'
+# frozen_string_literal: true
 
-require 'sidekiq/debouncer/version'
+require "sidekiq/debouncer/version"
+require "sidekiq/debouncer/errors"
+require "sidekiq/debouncer/middleware/client"
+require "sidekiq/debouncer/middleware/server"
 
 module Sidekiq
   module Debouncer
@@ -10,38 +12,9 @@ module Sidekiq
     end
 
     module ClassMethods
-      DEFAULT_DEBOUNCE_FOR = 5 * 60 # 5.minutes
-      DEFAULT_DEBOUNCE_BY = -> (job_args) { 0 }
-
-      def debounce(*args)
-        sidekiq_options["debounce"] ||= {}
-
-        debounce_for = sidekiq_options["debounce"][:time] || DEFAULT_DEBOUNCE_FOR
-        debounce_by = sidekiq_options["debounce"][:by] || DEFAULT_DEBOUNCE_BY
-        debounce_by_value = debounce_by.is_a?(Symbol) ? send(debounce_by, args) : debounce_by.call(args)
-
-        ss = Sidekiq::ScheduledSet.new
-        jobs = ss.select do |job|
-          next false unless job.klass == self.to_s
-
-          debounce_by_value_job = debounce_by.is_a?(Symbol) ? send(debounce_by, job.args[0][0]) : debounce_by.call(job.args[0][0])
-
-          debounce_by_value_job == debounce_by_value
-        end
-
-        time_from_now = Time.now + debounce_for
-        jobs_to_group = []
-
-        jobs.each do |job|
-          if job.at > Time.now && job.at < time_from_now
-            jobs_to_group += job.args[0]
-            job.delete
-          end
-        end
-
-        jobs_to_group << args
-
-        perform_in(debounce_for, jobs_to_group)
+      def debounce(...)
+        warn "WARNING: debounce method is deprecated, use perform_async instead"
+        perform_async(...)
       end
     end
   end

data/lib/sidekiq-debouncer.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/debouncer"

data/sidekiq-debouncer.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "sidekiq/debouncer/version"
+
+Gem::Specification.new do |gem|
+  gem.name = "sidekiq-debouncer"
+  gem.version = Sidekiq::Debouncer::VERSION
+  gem.authors = ["Sebastian Zuchmański", "Karol Bąk"]
+  gem.email = ["sebcioz@gmail.com", "kukicola@gmail.com"]
+  gem.summary = "Sidekiq extension that adds the ability to debounce job execution"
+  gem.description = <<~DESCRIPTION
+    Worker will postpone its execution after `wait time` have elapsed since the last time it was invoked.
+    Useful for implementing behavior that should only happen after the input has stopped arriving.
+  DESCRIPTION
+  gem.homepage = "https://github.com/paladinsoftware/sidekiq-debouncer"
+  gem.license = "MIT"
+  gem.required_ruby_version = ">= 2.7.0"
+
+  gem.files = Dir.glob("lib/**/*") + [
+    "CHANGELOG.md",
+    "LICENSE.txt",
+    "README.md",
+    "sidekiq-debouncer.gemspec"
+  ]
+
+  gem.add_dependency "sidekiq", ">= 6.5", "< 8.0"
+
+  gem.add_development_dependency "rspec", "~> 3.12.0"
+  gem.add_development_dependency "timecop", "~> 0.9.6"
+  gem.add_development_dependency "simplecov", "~> 0.22.0"
+  gem.add_development_dependency "parallel", "~> 1.22.1"
+  gem.add_development_dependency "standard", "~> 1.24.3"
+end

metadata

@@ -1,141 +1,132 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-debouncer
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Sebastian Zuchmański
 - Karol Bąk
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-25 00:00:00.000000000 Z
+date: 2023-02-28 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.12.0
 - !ruby/object:Gem::Dependency
-  name: rspec-sidekiq
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.6
 - !ruby/object:Gem::Dependency
-  name: timecop
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.22.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.22.0
 - !ruby/object:Gem::Dependency
-  name: rspec-redis_helper
+  name: parallel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.22.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.22.1
 - !ruby/object:Gem::Dependency
-  name: redis-namespace
+  name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.24.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Sidekiq extension that adds the ability to debounce job execution.
+        version: 1.24.3
+description: |
+  Worker will postpone its execution after `wait time` have elapsed since the last time it was invoked.
+  Useful for implementing behavior that should only happen after the input has stopped arriving.
 email:
 - sebcioz@gmail.com
-- karol.bak@paladinsoftware.com
+- kukicola@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".semaphore/semaphore.yml"
-- Gemfile
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
-- gemfiles/sidekiq-5.0.5.gemfile
-- gemfiles/sidekiq-5.1.3.gemfile
-- gemfiles/sidekiq-5.2.7.gemfile
-- gemfiles/sidekiq-6.0.2.gemfile
+- lib/sidekiq-debouncer.rb
 - lib/sidekiq/debouncer.rb
+- lib/sidekiq/debouncer/errors.rb
+- lib/sidekiq/debouncer/lua/debounce.lua
+- lib/sidekiq/debouncer/middleware/client.rb
+- lib/sidekiq/debouncer/middleware/server.rb
 - lib/sidekiq/debouncer/version.rb
-- sidekiq-debounce.gemspec
-- spec/sidekiq/debouncer_spec.rb
-- spec/spec_helper.rb
+- sidekiq-debouncer.gemspec
 homepage: https://github.com/paladinsoftware/sidekiq-debouncer
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -143,17 +134,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
-summary: ''
-test_files:
-- spec/sidekiq/debouncer_spec.rb
-- spec/spec_helper.rb
+summary: Sidekiq extension that adds the ability to debounce job execution
+test_files: []

data/.gitignore

@@ -1,19 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.rspec-local
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-gemfiles/*.gemfile.lock
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/.semaphore/semaphore.yml

@@ -1,27 +0,0 @@
-version: v1.0
-name: Sidekiq-debouncer CI pipeline
-agent:
-  machine:
-    type: e1-standard-2
-    os_image: ubuntu1804
-
-blocks:
-  - name: Run specs
-    task:
-      env_vars:
-        - name: RAILS_ENV
-          value: "test"
-
-      jobs:
-        - name: Run RSpec
-          matrix:
-            - env_var: SIDEKIQ_VERSION
-              values: [ "5.0.5", "5.1.3", "5.2.7", "6.0.2" ]
-          commands:
-            - checkout
-            - export RUBY_VERSION=$(cat gemfiles/sidekiq-$SIDEKIQ_VERSION.gemfile | grep "ruby \".*\"" | grep -o "[0-9]\.[0-9]\.[0-9]")
-            - sem-version ruby $RUBY_VERSION
-            - sem-service start redis
-            - gem install bundler -v 1.17.3 -N
-            - bundle install --gemfile gemfiles/sidekiq-$SIDEKIQ_VERSION.gemfile
-            - RAILS_ENV=test bundle exec --gemfile gemfiles/sidekiq-$SIDEKIQ_VERSION.gemfile rspec

data/Gemfile

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec

data/gemfiles/sidekiq-5.0.5.gemfile

@@ -1,7 +0,0 @@
-source 'https://rubygems.org'
-
-ruby "2.3.8"
-
-gem "sidekiq", "= 5.0.5"
-
-gemspec path: '../'

data/gemfiles/sidekiq-5.1.3.gemfile

@@ -1,7 +0,0 @@
-source 'https://rubygems.org'
-
-ruby "2.4.6"
-
-gem "sidekiq", "= 5.1.3"
-
-gemspec path: '../'

data/gemfiles/sidekiq-5.2.7.gemfile

@@ -1,7 +0,0 @@
-source 'https://rubygems.org'
-
-ruby "2.5.5"
-
-gem "sidekiq", "= 5.2.7"
-
-gemspec path: '../'

data/gemfiles/sidekiq-6.0.2.gemfile

@@ -1,7 +0,0 @@
-source 'https://rubygems.org'
-
-ruby "2.6.5"
-
-gem "sidekiq", "= 6.0.2"
-
-gemspec path: '../'

data/sidekiq-debounce.gemspec

@@ -1,28 +0,0 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'sidekiq/debouncer/version'
-
-Gem::Specification.new do |gem|
-  gem.name          = 'sidekiq-debouncer'
-  gem.version       = Sidekiq::Debouncer::VERSION
-  gem.authors       = ['Sebastian Zuchmański', 'Karol Bąk']
-  gem.email         = ['sebcioz@gmail.com', 'karol.bak@paladinsoftware.com']
-  gem.description   = %q{Sidekiq extension that adds the ability to debounce job execution.}
-  gem.summary       = %q{}
-  gem.homepage      = 'https://github.com/paladinsoftware/sidekiq-debouncer'
-  gem.license       = 'MIT'
-
-  gem.files         = `git ls-files`.split($/)
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = %w(lib)
-
-  gem.add_dependency 'activesupport'
-  gem.add_dependency 'sidekiq', '>= 5.0'
-
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'rspec-sidekiq'
-  gem.add_development_dependency 'timecop'
-  gem.add_development_dependency 'rspec-redis_helper'
-  gem.add_development_dependency 'redis-namespace'
-end

data/spec/sidekiq/debouncer_spec.rb

@@ -1,202 +0,0 @@
-require 'spec_helper'
-
-class TestWorker
-  include Sidekiq::Worker
-  include Sidekiq::Debouncer
-
-  sidekiq_options(
-    debounce: {
-      time: 5 * 60,
-      by: -> (job_args) {
-        job_args[0]
-      }
-    }
-  )
-
-  # group - array of arguments for single job
-  def perform(group)
-    group.each do
-      # do some work with group
-    end
-  end
-end
-
-class TestWorkerWithMultipleArguments
-  include Sidekiq::Worker
-  include Sidekiq::Debouncer
-
-  sidekiq_options(
-    debounce: {
-      time: 5 * 60,
-      by: -> (job_args) {
-        job_args[0] + job_args[1]
-      }
-    }
-  )
-
-  # group - array of arguments for single job
-  def perform(group)
-    group.each do
-      # do some work with group
-    end
-  end
-end
-
-class TestWorkerWithSymbolAsDebounce
-  include Sidekiq::Worker
-  include Sidekiq::Debouncer
-
-  sidekiq_options(
-    debounce: {
-      time: 5 * 60,
-      by: :debounce_method
-    }
-  )
-
-  def self.debounce_method(args)
-    args[0]
-  end
-
-  # group - array of arguments for single job
-  def perform(group)
-    group.each do
-      # do some work with group
-    end
-  end
-end
-
-describe Sidekiq::Debouncer do
-  let(:time_start) { Time.new(2016, 1, 1, 12, 0, 0) }
-
-  before do
-    Timecop.freeze(time_start)
-    Sidekiq::ScheduledSet.new.clear
-    Sidekiq::Testing.disable!
-  end
-
-  context "1 type of tasks" do
-    context "1 task" do
-      it "executes it after 5 minutes" do
-        TestWorker.debounce("A", "job 1")
-
-        expect(Sidekiq::ScheduledSet.new.size).to eq(1)
-
-        group = Sidekiq::ScheduledSet.new.first
-        expect(group.args[0]).to eq([["A", "job 1"]])
-        expect(group.at.to_i).to eq((time_start + 5 * 60).to_i)
-      end
-
-      it "executes it after 5 minutes for symbol debounce" do
-        expect(TestWorkerWithSymbolAsDebounce).to receive(:debounce_method).with(["A", "job 1"]).once.and_call_original
-        TestWorkerWithSymbolAsDebounce.debounce("A", "job 1")
-
-        expect(Sidekiq::ScheduledSet.new.size).to eq(1)
-
-        group = Sidekiq::ScheduledSet.new.first
-        expect(group.args[0]).to eq([["A", "job 1"]])
-        expect(group.at.to_i).to eq((time_start + 5 * 60).to_i)
-      end
-    end
-
-    context "1 task, 3 minutes break, 1 task" do
-      it "executes both tasks after 8 minutes for multiple arguments" do
-        TestWorkerWithMultipleArguments.debounce(1, 5)
-        Timecop.freeze(time_start + 3 * 60)
-        TestWorkerWithMultipleArguments.debounce(3, 3)
-
-        expect(Sidekiq::ScheduledSet.new.size).to eq(1)
-        group = Sidekiq::ScheduledSet.new.first
-        expect(group.args[0]).to eq([[1, 5], [3, 3]])
-        expect(group.at.to_i).to be((time_start + 8 * 60).to_i)
-      end
-
-      it "executes both tasks after 8 minutes" do
-        TestWorker.debounce("A", "job 1")
-        Timecop.freeze(time_start + 3 * 60)
-        TestWorker.debounce("A", "job 2")
-
-        expect(Sidekiq::ScheduledSet.new.size).to eq(1)
-        group = Sidekiq::ScheduledSet.new.first
-        expect(group.args[0]).to eq([["A", "job 1"], ["A", "job 2"]])
-        expect(group.at.to_i).to be((time_start + 8 * 60).to_i)
-      end
-
-      it "executes both tasks after 8 minutes for symbol debounce" do
-        TestWorkerWithSymbolAsDebounce.debounce("A", "job 1")
-        Timecop.freeze(time_start + 3 * 60)
-        TestWorkerWithSymbolAsDebounce.debounce("A", "job 2")
-
-        expect(Sidekiq::ScheduledSet.new.size).to eq(1)
-        group = Sidekiq::ScheduledSet.new.first
-        expect(group.args[0]).to eq([["A", "job 1"], ["A", "job 2"]])
-        expect(group.at.to_i).to be((time_start + 8 * 60).to_i)
-      end
-    end
-
-    context "1 task, 3 minutes break, 1 task, 6 minutes break, 1 task" do
-      it "executes two tasks after 8 minutes, the last one in 14 minutes" do
-        TestWorker.debounce("A", "job 1")
-        Timecop.freeze(time_start + 3 * 60)
-        TestWorker.debounce("A", "job 2")
-        Timecop.freeze(time_start + 3 * 60 + 6 * 60)
-        TestWorker.debounce("A", "job 3")
-
-        expect(Sidekiq::ScheduledSet.new.size).to eq(2)
-
-        groups = Sidekiq::ScheduledSet.new.to_a.sort_by { |g| g.at.to_i }
-
-        expect(groups[0].args[0]).to eq([["A", "job 1"], ["A", "job 2"]])
-        expect(groups[0].at.to_i).to be((time_start + 8 * 60).to_i)
-
-        expect(groups[1].args[0]).to eq([["A", "job 3"]])
-        expect(groups[1].at.to_i).to be((time_start + 14 * 60).to_i)
-      end
-    end
-
-    context "1 task, 6 minutes break, 1 task" do
-      it "executes first task, the second one in 11 minutes" do
-        TestWorker.debounce("A", "job 1")
-        Timecop.freeze(time_start + 6 * 60)
-        TestWorker.debounce("A", "job 2")
-
-        expect(Sidekiq::ScheduledSet.new.size).to eq(2)
-
-        groups = Sidekiq::ScheduledSet.new.to_a.sort_by { |g| g.at.to_i }
-
-        expect(groups[0].args[0]).to eq([["A", "job 1"]])
-        expect(groups[0].at.to_i).to be((time_start + 5 * 60).to_i)
-
-        expect(groups[1].args[0]).to eq([["A", "job 2"]])
-        expect(groups[1].at.to_i).to be((time_start + 11 * 60).to_i)
-      end
-    end
-  end
-
-  context "two types of tasks" do
-    context "A task, 3 minutes break, A and B tasks, 3 minutes break, B task, 6 minutes break, B task" do
-      it "executes two A tasks after 8 minuts, two B tasks after 11 minutes, last B task after 17 minutes" do
-        TestWorker.debounce("A", "job 1")
-        Timecop.freeze(time_start + 3 * 60)
-        TestWorker.debounce("A", "job 2")
-        TestWorker.debounce("B", "job 3")
-        Timecop.freeze(time_start + 3 * 60 + 3 * 60)
-        TestWorker.debounce("B", "job 4")
-        Timecop.freeze(time_start + 3 * 60 + 3 * 60 + 6 * 60)
-        TestWorker.debounce("B", "job 5")
-
-        expect(Sidekiq::ScheduledSet.new.size).to eq(3)
-
-        groups = Sidekiq::ScheduledSet.new.to_a.sort_by { |g| g.at.to_i }
-
-        expect(groups[0].args[0]).to eq([["A", "job 1"], ["A", "job 2"]])
-        expect(groups[0].at.to_i).to be((time_start + 8 * 60).to_i)
-
-        expect(groups[1].args[0]).to eq([["B", "job 3"], ["B", "job 4"]])
-        expect(groups[1].at.to_i).to be((time_start + 11 * 60).to_i)
-
-        expect(groups[2].args[0]).to eq([["B", "job 5"]])
-        expect(groups[2].at.to_i).to be((time_start + 17 * 60).to_i)
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,18 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'rspec'
-require 'redis/namespace'
-require 'rspec-sidekiq'
-require 'timecop'
-
-require 'sidekiq/debouncer'
-
-RSpec.configure do |config|
-  config.order = 'random'
-  config.color = true
-
-  Sidekiq.configure_server do |config|
-    config.redis[:namespace] = { namespace: 'sidekiq-debouncer' }
-  end
-end