sidekiq-grouping 1.0.10 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd82358a1dc3ea13dcebc3d113272316e3c334fa3e562dad7eb2828590626988
-  data.tar.gz: 90a9116faf2392b7b5d81ce80346afd3741c897bf60b215eaac43f954e5fcb38
+  metadata.gz: 1626ba86eaf1cb747b25ca6770aa5fa982fbc19f4b8f55bdb49983331ffa8761
+  data.tar.gz: bdd1ee7ec9d60582fdf2db69edacbb5a3592f1caa77d60ea60e09f259a0dbca4
 SHA512:
-  metadata.gz: f08a2fe6ed7811eefae95487143f0db3beb5343c3c3b11b2e7472b805b9eb0a5b6394c84b933219bf2648e6706a463bfc2cd30f1f1e623f48e665d9dec452b0d
-  data.tar.gz: ca99dbc220c9e757549bfd5659ac0673db96f1eadb394b2a396eb7581df482156c83bb107eee98e91744f0f7d93663d393d25f1b7996aac2df84f5e09d69baa3
+  metadata.gz: 99cfd0e831a581d1f38764f1803e81fcdd4ae5b2fd7a75fa8b19a936af601abc415031213f8419d16f3108d8ba8a980439b148e55ae2b64ebc89e674d4c2b780
+  data.tar.gz: 9b98e1272e011f68fc60766918f16cb80ce867eb351d05b65ac8a760dbfe05fe363b74a276794b80a6971e5b4593d2c423d35ad835ad7bbdb00d6ca911490e94

data/.github/workflows/lint.yml

@@ -0,0 +1,37 @@
+---
+name: Lint
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  rubocop:
+    name: Rubocop
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Ruby ${{ matrix.ruby_version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler: 2
+          ruby-version: 2.7
+
+      - uses: actions/cache@v3
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ matrix.ruby-version }}-${{ hashFiles('./*.gemspec') }}
+          restore-keys: |
+            ${{ runner.os }}-gems-
+
+      - name: Bundle install
+        run: |
+          bundle config path vendor/bundle
+          bundle install --jobs 4 --retry 3
+
+      - name: Run Rubocop
+        run: bundle exec rubocop

data/.github/workflows/test.yml

@@ -0,0 +1,49 @@
+---
+name: Test
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  rspec:
+    name: Rspec
+    runs-on: ubuntu-latest
+    services:
+      redis:
+        image: redis:6
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 6379:6379
+    strategy:
+      matrix:
+        include:
+          - { ruby_version: 2.7 }
+          - { ruby_version: 3.0 }
+          - { ruby_version: 3.1 }
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Ruby ${{ matrix.ruby_version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler: 2
+          ruby-version: ${{ matrix.ruby_version }}
+
+      # Appraisal doesn't support vendored install
+      # See: https://github.com/thoughtbot/appraisal/issues/173
+      #      https://github.com/thoughtbot/appraisal/pull/174
+      - name: Bundle install
+        run: |
+          bundle install --jobs 4 --retry 3
+          bundle exec appraisal install
+
+      - name: Run tests
+        run: bundle exec appraisal rspec

data/.gitignore

@@ -16,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.lefthook-local.yml

data/.rubocop.yml

@@ -1,8 +1,15 @@
+---
 require: rubocop-rspec
 
 AllCops:
+  TargetRubyVersion: 2.7.0
+  SuggestExtensions: false
+  NewCops: enable
   Include:
     - ./Gemfile
+    - ./Rakefile
+    - '*.gemspec'
+    - '**/*.rb'
 
 Documentation:
   Enabled: false
@@ -10,8 +17,29 @@ Documentation:
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
-Style/ClassAndModuleChildren:
-  EnforcedStyle: compact
-
 RSpec/FilePath:
   Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/AnyInstance:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 15
+
+Metrics/ClassLength:
+  Max: 150
+
+Layout/LineLength:
+  Max: 80
+
+Layout/FirstArgumentIndentation:
+  EnforcedStyle: consistent
+
+Layout/FirstMethodArgumentLineBreak:
+  Enabled: true
+
+Layout/MultilineMethodArgumentLineBreaks:
+  Enabled: true

data/Appraisals

@@ -14,6 +14,18 @@ appraise 'sidekiq-5.0' do
   gem 'sidekiq', '~> 5.0.0'
 end
 
+appraise 'sidekiq-6.0' do
+  gem 'sidekiq', '~> 6.0.0'
+end
+
+appraise 'sidekiq-6.5' do
+  gem 'sidekiq', '~> 6.5.0'
+end
+
+appraise 'sidekiq-7.0' do
+  gem 'sidekiq', '~> 7.0.0'
+end
+
 appraise 'sidekiq-master' do
   gem 'sidekiq', github: 'mperham/sidekiq'
 end

data/README.md

@@ -1,3 +1,5 @@
+[![Gem Version](https://badge.fury.io/rb/sidekiq-grouping.svg)](https://rubygems.org/gems/sidekiq-grouping)
+
 # Sidekiq::Grouping
 
 <a href="https://evilmartians.com/?utm_source=sidekiq-grouping-gem">
@@ -23,7 +25,7 @@ class ElasticBulkIndexWorker
   include Sidekiq::Worker
 
   sidekiq_options(
-    queue: :elasic_bulks,
+    queue: :elastic_bulks,
     batch_flush_size: 30,     # Jobs will be combined when queue size exceeds 30
     batch_flush_interval: 60, # Jobs will be combined every 60 seconds
     retry: 5

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "sidekiq/grouping"
+
+require "pry"
+Pry.start

data/gemfiles/sidekiq_6.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "sidekiq", "~> 6.0.0"
+
+gemspec path: "../"

data/gemfiles/sidekiq_6.5.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "sidekiq", "~> 6.5.0"
+
+gemspec path: "../"

data/gemfiles/sidekiq_7.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "sidekiq", "~> 7.0.0"
+
+gemspec path: "../"

data/lefthook.yml

@@ -0,0 +1,20 @@
+---
+# Git hooks configuration
+#
+# See: github.com/evilmartians/lefthook
+
+pre-commit:
+  parallel: true
+  commands:
+    appraisal:
+      glob: "{Appraisals,*.gemfile}"
+      run: echo {staged_files} > /dev/null; bundle exec appraisal install && git add gemfiles/*.gemfile
+    rubocop:
+      glob: "{*.rb,*.gemspec,Gemfile,Rakefile}"
+      run: bundle exec rubocop -A {staged_files} && git add {staged_files}
+
+pre-push:
+  commands:
+    rspec:
+      glob: "*.rb"
+      run: echo {push_files} > /dev/null; bundle exec appraisal rspec

data/lib/sidekiq/grouping/batch.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Grouping
     class Batch
-      def initialize(worker_class, queue, redis_pool = nil)
+      def initialize(worker_class, queue, _redis_pool = nil)
         @worker_class = worker_class
         @queue = queue
         @name = "#{worker_class.underscore}:#{queue}"
@@ -12,11 +14,18 @@ module Sidekiq
 
       def add(msg)
         msg = msg.to_json
-        @redis.push_msg(@name, msg, enqueue_similar_once?) if should_add? msg
+        return unless should_add? msg
+
+        @redis.push_msg(
+          @name,
+          msg,
+          remember_unique: enqueue_similar_once?
+        )
       end
 
-      def should_add? msg
+      def should_add?(msg)
         return true unless enqueue_similar_once?
+
         !@redis.enqueued?(@name, msg)
       end
 
@@ -25,19 +34,19 @@ module Sidekiq
       end
 
       def chunk_size
-        worker_class_options['batch_size'] ||
+        worker_class_options["batch_size"] ||
           Sidekiq::Grouping::Config.max_batch_size
       end
 
       def pluck_size
-        worker_class_options['batch_flush_size'] ||
+        worker_class_options["batch_flush_size"] ||
           chunk_size
       end
 
       def pluck
-        if @redis.lock(@name)
-          @redis.pluck(@name, pluck_size).map { |value| JSON.parse(value) }
-        end
+        return unless @redis.lock(@name)
+
+        @redis.pluck(@name, pluck_size).map { |value| JSON.parse(value) }
       end
 
       def flush
@@ -46,9 +55,9 @@ module Sidekiq
 
         chunk.each_slice(chunk_size) do |subchunk|
           Sidekiq::Client.push(
-            'class' => @worker_class,
-            'queue' => @queue,
-            'args' => [true, subchunk]
+            "class" => @worker_class,
+            "queue" => @queue,
+            "args" => [true, subchunk]
           )
         end
         set_current_time_as_last
@@ -74,10 +83,11 @@ module Sidekiq
       end
 
       def next_execution_time
-        if interval = worker_class_options['batch_flush_interval']
-          last_time = last_execution_time
-          last_time + interval.seconds if last_time
-        end
+        interval = worker_class_options["batch_flush_interval"]
+        return unless interval
+
+        last_time = last_execution_time
+        last_time + interval.seconds if last_time
       end
 
       def delete
@@ -99,13 +109,13 @@ module Sidekiq
         if last_time.blank?
           set_current_time_as_last
           false
-        else
-          next_time < Time.now if next_time
+        elsif next_time
+          next_time < Time.now
         end
       end
 
       def enqueue_similar_once?
-        worker_class_options['batch_unique'] == true
+        worker_class_options["batch_unique"] == true
       end
 
       def set_current_time_as_last
@@ -122,7 +132,7 @@ module Sidekiq
         end
 
         def extract_worker_klass_and_queue(name)
-          klass, queue = name.split(':')
+          klass, queue = name.split(":")
           [klass.camelize, queue]
         end
       end

data/lib/sidekiq/grouping/config.rb

@@ -1,29 +1,41 @@
-module Sidekiq::Grouping::Config
-  include ActiveSupport::Configurable
+# frozen_string_literal: true
 
-  def self.options
-    Sidekiq.options[:grouping] || Sidekiq.options["grouping"] || {} # sidekiq 5.x use symbol in keys
-  end
+module Sidekiq
+  module Grouping
+    module Config
+      include ActiveSupport::Configurable
 
-  # Queue size overflow check polling interval
-  config_accessor :poll_interval do
-    options[:poll_interval] || 3
-  end
+      def self.options
+        if Sidekiq.respond_to?(:[]) # Sidekiq 6.x
+          Sidekiq[:grouping] || {}
+        elsif Sidekiq.respond_to?(:options) # Sidekiq <= 5.x
+          Sidekiq.options[:grouping] || Sidekiq.options["grouping"] || {}
+        else # Sidekiq 7.x
+          Sidekiq.default_configuration[:grouping] || {}
+        end
+      end
 
-  # Maximum batch size
-  config_accessor :max_batch_size do
-    options[:max_batch_size] || 1000
-  end
+      # Queue size overflow check polling interval
+      config_accessor :poll_interval do
+        options[:poll_interval] || 3
+      end
 
-  # Batch queue flush lock timeout
-  config_accessor :lock_ttl do
-    options[:lock_ttl] || 1
-  end
+      # Maximum batch size
+      config_accessor :max_batch_size do
+        options[:max_batch_size] || 1000
+      end
+
+      # Batch queue flush lock timeout
+      config_accessor :lock_ttl do
+        options[:lock_ttl] || 1
+      end
 
-  # Option to override how Sidekiq::Grouping know about tests env
-  config_accessor :tests_env do
-    options[:tests_env] || (
-      defined?(::Rails) && Rails.respond_to?(:env) && Rails.env.test?
-    )
+      # Option to override how Sidekiq::Grouping know about tests env
+      config_accessor :tests_env do
+        options[:tests_env] || (
+          defined?(::Rails) && Rails.respond_to?(:env) && Rails.env.test?
+        )
+      end
+    end
   end
 end

data/lib/sidekiq/grouping/flusher.rb

@@ -1,42 +1,54 @@
-class Sidekiq::Grouping::Flusher
-  def flush
-    batches = Sidekiq::Grouping::Batch.all.map do |batch|
-      batch if batch.could_flush?
-    end
-    flush_batches(batches)
-  end
+# frozen_string_literal: true
 
-  def force_flush_for_test!
-    unless Sidekiq::Grouping::Config.tests_env
-      Sidekiq::Grouping.logger.warn(
-        "**************************************************"
-      )
-      Sidekiq::Grouping.logger.warn([
-        "⛔️ force_flush_for_test! for testing API, ",
-        "but this is not the test environment. ",
-        "Please check your environment or ",
-        "change 'tests_env' to cover this one"
-      ].join)
-      Sidekiq::Grouping.logger.warn(
-        "**************************************************"
-      )
-    end
-    flush_batches(Sidekiq::Grouping::Batch.all)
-  end
+module Sidekiq
+  module Grouping
+    class Flusher
+      def flush
+        batches = Sidekiq::Grouping::Batch.all.map do |batch|
+          batch if batch.could_flush?
+        end
+        flush_batches(batches)
+      end
 
-  private
+      def force_flush_for_test!
+        unless Sidekiq::Grouping::Config.tests_env
+          Sidekiq::Grouping.logger.warn(
+            "**************************************************"
+          )
+          Sidekiq::Grouping.logger.warn(
+            "⛔️ force_flush_for_test! for testing API, " \
+            "but this is not the test environment. " \
+            "Please check your environment or " \
+            "change 'tests_env' to cover this one"
+          )
+          Sidekiq::Grouping.logger.warn(
+            "**************************************************"
+          )
+        end
+        flush_batches(Sidekiq::Grouping::Batch.all)
+      end
 
-  def flush_batches(batches)
-    batches.compact!
-    flush_concrete(batches)
-  end
+      private
+
+      def flush_batches(batches)
+        batches.compact!
+        flush_concrete(batches)
+      end
 
-  def flush_concrete(batches)
-    return if batches.empty?
-    names = batches.map { |batch| "#{batch.worker_class} in #{batch.queue}" }
-    Sidekiq::Grouping.logger.info(
-      "[Sidekiq::Grouping] Trying to flush batched queues: #{names.join(',')}"
-    ) unless Sidekiq::Grouping::Config.tests_env
-    batches.each(&:flush)
+      def flush_concrete(batches)
+        return if batches.empty?
+
+        names = batches.map do |batch|
+          "#{batch.worker_class} in #{batch.queue}"
+        end
+        unless Sidekiq::Grouping::Config.tests_env
+          Sidekiq::Grouping.logger.info(
+            "[Sidekiq::Grouping] Trying to flush batched queues: " \
+            "#{names.join(',')}"
+          )
+        end
+        batches.each(&:flush)
+      end
+    end
   end
 end

data/lib/sidekiq/grouping/flusher_observer.rb

@@ -1,13 +1,19 @@
-class Sidekiq::Grouping::FlusherObserver
-  def update(time, _result, ex)
-    if ex.is_a?(Concurrent::TimeoutError)
-      Sidekiq::Grouping.logger.error(
-        "[Sidekiq::Grouping] (#{time}) Execution timed out\n"
-      )
-    elsif ex.present?
-      Sidekiq::Grouping.logger.error(
-        "[Sidekiq::Grouping] Execution failed with error #{ex}\n"
-      )
+# frozen_string_literal: true
+
+module Sidekiq
+  module Grouping
+    class FlusherObserver
+      def update(time, _result, exception)
+        if exception.is_a?(Concurrent::TimeoutError)
+          Sidekiq::Grouping.logger.error(
+            "[Sidekiq::Grouping] (#{time}) Execution timed out\n"
+          )
+        elsif exception.present?
+          Sidekiq::Grouping.logger.error(
+            "[Sidekiq::Grouping] Execution failed with error #{exception}\n"
+          )
+        end
+      end
     end
   end
 end

data/lib/sidekiq/grouping/middleware.rb

@@ -1,43 +1,56 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Grouping
     class Middleware
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def call(worker_class, msg, queue, redis_pool = nil)
-        return yield if (defined?(Sidekiq::Testing) && Sidekiq::Testing.inline?)
-
-        worker_class = worker_class.camelize.constantize if worker_class.is_a?(String)
+        if worker_class.is_a?(String)
+          worker_class = worker_class.camelize.constantize
+        end
         options = worker_class.get_sidekiq_options
 
         batch =
-          options.key?('batch_flush_size') ||
-          options.key?('batch_flush_interval') ||
-          options.key?('batch_size')
+          options.key?("batch_flush_size") ||
+          options.key?("batch_flush_interval") ||
+          options.key?("batch_size")
 
         passthrough =
-          msg['args'] &&
-          msg['args'].is_a?(Array) &&
-          msg['args'].try(:first) == true
+          msg["args"].is_a?(Array) &&
+          msg["args"].try(:first) == true
 
         retrying = msg["failed_at"].present?
 
         return yield unless batch
 
-        if !(passthrough || retrying)
-          add_to_batch(worker_class, queue, msg, redis_pool)
-        else
-          msg['args'].shift if passthrough
+        if inline_mode?
+          wrapped_args = [[msg["args"]]]
+          msg["args"] = wrapped_args
+          return yield
+        end
+
+        if passthrough || retrying
+          msg["args"].shift if passthrough
           yield
+        else
+          add_to_batch(worker_class, queue, msg, redis_pool)
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       private
 
       def add_to_batch(worker_class, queue, msg, redis_pool = nil)
         Sidekiq::Grouping::Batch
           .new(worker_class.name, queue, redis_pool)
-          .add(msg['args'])
+          .add(msg["args"])
 
         nil
       end
+
+      def inline_mode?
+        defined?(Sidekiq::Testing) && Sidekiq::Testing.inline?
+      end
     end
   end
 end