sidekiq-middleware 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f04e949a14e7c6eaf7d746573daebbf25ec154f1
-  data.tar.gz: 8de3085809a52b856ad510a9cab0c8d2abb51144
+  metadata.gz: b188c23f68544df2038746bd369ba9d4ab965b3f
+  data.tar.gz: 4c3b61f360e917fd733b247d6aa60349a11b2270
 SHA512:
-  metadata.gz: 39b268d9dfbd5c1b95171ff061ac0ed5dc99f803c166baf753b60bc0f58fbaadf07eb76a6a25f6b34cc1532acf04bfea909118edfc286a4efcae92f428319975
-  data.tar.gz: c1b11188de319b8444aa07ce074a9b66a111225bbd7bb00c4cd0b392005e1696417cb95fd17b8cd620c076a1856b8f77a4d5afce5515ff757276cd6a5e2302ce
+  metadata.gz: aca4da5872a73e6da626ff87cccc48653238dae8aa88580837e16605d1d23e8dda8980177f24832af564cb472d21f56b4801fdbe3eca684f389ac4adde9ba30c
+  data.tar.gz: a3eaa745e7d6cfca147602a7845994e3f53f6660b2e7b9a8cf86fd3a31ebdcc14857d49712e2224ac9e8cbc3a21a7cc380854d13d818fb8f9ccbee9ed7cb2d2f

data/.travis.yml

@@ -1,8 +1,10 @@
 language: ruby
 rvm:
   - 1.9.3
+  - 2.0.0
+  - 2.1.0
 branches:
   only:
     - master
 services:
-  - redis
+  - redis

data/CHANGES.md

@@ -1,3 +1,8 @@
+0.2.0
+-----------
+
+- Fix scheduled jobs locking when ```unique``` is not set to ```:all``` ([dimko](https://github.com/dimko))
+
 0.1.4
 -----------
 

data/Gemfile

@@ -2,5 +2,6 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'simplecov', :require => false
-end
+  gem 'simplecov', require: false
+  gem 'coveralls', require: false
+end

data/README.md

@@ -1,4 +1,11 @@
-# Additional sidekiq middleware [![Build Status](https://secure.travis-ci.org/krasnoukhov/sidekiq-middleware.png)](http://travis-ci.org/krasnoukhov/sidekiq-middleware)
+# Additional sidekiq middleware
+
+[![Gem Version](https://badge.fury.io/rb/sidekiq-middleware.png)](http://badge.fury.io/rb/sidekiq-middleware)
+[![Dependency Status](https://gemnasium.com/krasnoukhov/sidekiq-middleware.png)](https://gemnasium.com/krasnoukhov/sidekiq-middleware)
+[![Code Climate](https://codeclimate.com/github/krasnoukhov/sidekiq-middleware.png)](https://codeclimate.com/github/krasnoukhov/sidekiq-middleware)
+[![Build Status](https://secure.travis-ci.org/krasnoukhov/sidekiq-middleware.png)](http://travis-ci.org/krasnoukhov/sidekiq-middleware)
+[![Coverage Status](https://coveralls.io/repos/krasnoukhov/sidekiq-middleware/badge.png)](https://coveralls.io/r/krasnoukhov/sidekiq-middleware)
+
 
 This gem provides additional middleware for [Sidekiq](https://github.com/mperham/sidekiq).
 

data/lib/sidekiq-middleware.rb

@@ -1,7 +1,7 @@
-require "digest"
-require "sidekiq-middleware/version"
-require "sidekiq-middleware/core_ext"
-require "sidekiq-middleware/unique_key"
-require "sidekiq-middleware/server/unique_jobs"
-require "sidekiq-middleware/client/unique_jobs"
-require "sidekiq-middleware/middleware"
+require 'digest/md5'
+require 'sidekiq-middleware/version'
+require 'sidekiq-middleware/core_ext'
+require 'sidekiq-middleware/worker'
+require 'sidekiq-middleware/server/unique_jobs'
+require 'sidekiq-middleware/client/unique_jobs'
+require 'sidekiq-middleware/middleware'

data/lib/sidekiq-middleware/client/unique_jobs.rb

@@ -2,37 +2,33 @@ module Sidekiq
   module Middleware
     module Client
       class UniqueJobs
-        HASH_KEY_EXPIRATION = 30 * 60
-
         def call(worker_class, item, queue)
           worker_class = worker_class.constantize if worker_class.is_a?(String)
-
-          enabled, expiration = worker_class.get_sidekiq_options['unique'],
-            (worker_class.get_sidekiq_options['expiration'] || HASH_KEY_EXPIRATION)
+          enabled = worker_class.unique_enabled?(item)
 
           if enabled
-            unique, payload = false, item.clone.slice(*%w(class queue args at))
+            expiration = worker_class.unique_exiration
             job_id = item['jid']
+            unique = false
 
-            # Enabled unique scheduled
-            if enabled == :all && payload.has_key?('at')
+            # Scheduled
+            if item.has_key?('at')
               # Use expiration period as specified in configuration,
               # but relative to job schedule time
-              expiration += (payload['at'].to_i - Time.now.to_i)
-              payload.delete('at')
+              expiration += (item['at'].to_i - Time.now.to_i)
             end
 
-            payload_hash = Sidekiq::Middleware::UniqueKey.generate(worker_class, payload)
+            unique_key = worker_class.unique_digest(item)
 
             Sidekiq.redis do |conn|
-              conn.watch(payload_hash)
+              conn.watch(unique_key)
 
-              locked_job_id = conn.get(payload_hash)
+              locked_job_id = conn.get(unique_key)
               if locked_job_id && locked_job_id != job_id
                 conn.unwatch
               else
                 unique = conn.multi do
-                  conn.setex(payload_hash, expiration, job_id)
+                  conn.setex(unique_key, expiration, job_id)
                 end
               end
             end

data/lib/sidekiq-middleware/server/unique_jobs.rb

@@ -2,34 +2,27 @@ module Sidekiq
   module Middleware
     module Server
       class UniqueJobs
-
         def call(worker_instance, item, queue)
-          manual = worker_instance.class.get_sidekiq_options['manual']
+          worker_class = worker_instance.class
+          enabled = worker_class.unique_enabled?(item)
 
-          begin
+          if enabled
+            begin
+              yield
+            ensure
+              unless worker_class.unique_manual?
+                clear(worker_class, item)
+              end
+            end
+          else
             yield
-          ensure
-            clear(worker_instance, item, queue) unless manual
           end
         end
 
-        def unique_lock_key(worker_instance, item, queue)
-          # Only enforce uniqueness across class, queue, args, and at.
-          # Useful when middleware uses the payload to store metadata.
-          enabled, payload = worker_instance.class.get_sidekiq_options['unique'],
-            item.clone.slice(*%w(class queue args at))
-
-          # Enabled unique scheduled
-          if enabled == :all && payload.has_key?('at')
-            payload.delete('at')
+        def clear(worker_class, item)
+          Sidekiq.redis do |conn|
+            conn.del worker_class.unique_digest(item)
           end
-
-          Sidekiq::Middleware::UniqueKey.generate(worker_instance.class, payload)
-        end
-
-        def clear(worker_instance, item, queue)
-          enabled = worker_instance.class.get_sidekiq_options['unique']
-          Sidekiq.redis { |conn| conn.del unique_lock_key(worker_instance, item, queue) } if enabled
         end
       end
     end

data/lib/sidekiq-middleware/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
   module Middleware
-    VERSION = "0.1.4"
+    VERSION = "0.2.0"
   end
 end

data/lib/sidekiq-middleware/worker.rb

@@ -0,0 +1,39 @@
+module Sidekiq
+  module Middleware
+    module Worker
+      UNIQUE_EXPIRATION = 30 * 60 # 30 minutes
+
+      def unique_digest(item)
+        if respond_to?(:lock)
+          args = item['args']
+          lock(*args)
+        else
+          dumped = Sidekiq.dump_json(item.slice('class', 'queue', 'args'))
+          digest = Digest::MD5.hexdigest(dumped)
+
+          "locks:unique:#{digest}"
+        end
+      end
+
+      def unique_exiration
+        get_sidekiq_options['expiration'] || UNIQUE_EXPIRATION
+      end
+
+      def unique_enabled?(item)
+        enabled = get_sidekiq_options['unique']
+        if item.has_key?('at') && enabled != :all
+          enabled = false
+        end
+        enabled
+      end
+
+      def unique_manual?
+        get_sidekiq_options['manual']
+      end
+    end
+  end
+end
+
+Sidekiq::Worker::ClassMethods.class_eval do
+  include Sidekiq::Middleware::Worker
+end

data/test/helper.rb

@@ -4,6 +4,9 @@ if ENV.has_key?('SIMPLECOV')
   SimpleCov.start
 end
 
+require 'coveralls'
+Coveralls.wear!
+
 require 'minitest/unit'
 require 'minitest/pride'
 require 'minitest/autorun'

data/test/test_unique_jobs.rb

@@ -1,4 +1,3 @@
-require 'securerandom'
 require 'helper'
 require 'timecop'
 require 'sidekiq/client'
@@ -31,147 +30,166 @@ class TestUniqueJobs < MiniTest::Unit::TestCase
       end
     end
 
-    class UniqueWorker
-      include Sidekiq::Worker
-      sidekiq_options queue: :unique_queue, unique: true
+    describe 'when unique option is disabled (unique: false)' do
+      class NotUniqueWorker
+        include Sidekiq::Worker
+        sidekiq_options queue: :not_unique_queue, unique: false
 
-      def perform(x)
+        def perform(x)
+        end
       end
-    end
-
-    it 'does not duplicate messages with enabled unique option' do
-      5.times { UniqueWorker.perform_async('args') }
-      assert_equal 1, Sidekiq.redis { |c| c.llen('queue:unique_queue') }
-    end
-
-    it 'discards non critical information about the message' do
-      5.times { Sidekiq::Client.push('class' => UniqueWorker, 'args' => ['critical'], 'sent_at' => Time.now.to_f, 'non' => 'critical') }
-      assert_equal 1, Sidekiq.redis { |c| c.llen('queue:unique_queue') }
-    end
-
-    class NotUniqueWorker
-      include Sidekiq::Worker
-      sidekiq_options queue: :not_unique_queue, unique: false
 
-      def perform(x)
+      it 'duplicates messages' do
+        5.times { NotUniqueWorker.perform_async('args') }
+        assert_equal 5, Sidekiq.redis { |c| c.llen('queue:not_unique_queue') }
       end
-    end
 
-    it 'duplicates messages with disabled unique option' do
-      5.times { NotUniqueWorker.perform_async('args') }
-      assert_equal 5, Sidekiq.redis { |c| c.llen('queue:not_unique_queue') }
+      it 'duplicates scheduled messages' do
+        at = Time.now.to_f
+        5.times { Sidekiq::Client.push('class' => NotUniqueWorker, 'args' => ['args'], 'at' => at) }
+        assert_equal 5, Sidekiq.redis { |c| c.zcard('schedule') }
+      end
     end
 
-    class UniqueScheduledWorker
-      include Sidekiq::Worker
-      sidekiq_options queue: :unique_scheduled_queue, unique: :all
+    describe 'when unique option is enabled (unique: true)' do
+      class UniqueWorker
+        include Sidekiq::Worker
+        sidekiq_options queue: :unique_queue, unique: true
 
-      def perform(x)
+        def perform(x)
+        end
       end
-    end
 
-    it 'does not duplicate scheduled messages with enabled unique option' do
-      5.times { |t| UniqueScheduledWorker.perform_in((t+1)*60, 'args') }
-      assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
-    end
+      it 'does not duplicate messages' do
+        5.times { UniqueWorker.perform_async('args') }
+        assert_equal 1, Sidekiq.redis { |c| c.llen('queue:unique_queue') }
+      end
 
-    it 'does correctly handle adding to the worker queue when scheduled' do
-      start_time = Time.now - 60
-      queue_time = start_time + 30
-      Timecop.travel start_time do
-        UniqueScheduledWorker.perform_at queue_time, 'x'
-      end
-      assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
-      assert_equal 0, Sidekiq.redis { |c| c.llen('queue:unique_scheduled_queue') }
-      Sidekiq::Scheduled::Poller.new.poll
-      assert_equal 0, Sidekiq.redis { |c| c.zcard('schedule') }
-      assert_equal 1, Sidekiq.redis { |c| c.llen('queue:unique_scheduled_queue') }
-    end
+      it 'discards non critical information about the message' do
+        5.times { Sidekiq::Client.push('class' => UniqueWorker, 'args' => ['critical'], 'sent_at' => Time.now.to_f, 'non' => 'critical') }
+        assert_equal 1, Sidekiq.redis { |c| c.llen('queue:unique_queue') }
+      end
 
-    it 'allows the job to be re-scheduled after processing' do
-      # Schedule
-      5.times { |t| UniqueScheduledWorker.perform_in((t+1)*60, 'args') }
-      assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
-
-      # Process
-      msg = Sidekiq.dump_json('class' => UniqueScheduledWorker.to_s, 'queue' => 'unique_scheduled_queue', 'args' => ['args'])
-      actor = MiniTest::Mock.new
-      actor.expect(:processor_done, nil, [@processor])
-      actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-      2.times { @boss.expect(:async, actor, []) }
-      work = UnitOfWork.new('default', msg)
-      @processor.process(work)
-
-      # Re-schedule
-      5.times { |t| UniqueScheduledWorker.perform_in((t+1)*60, 'args') }
-      assert_equal 2, Sidekiq.redis { |c| c.zcard('schedule') }
+      it 'duplicates scheduled messages' do
+        at = Time.now.to_f
+        5.times { Sidekiq::Client.push('class' => UniqueWorker, 'args' => ['args'], 'at' => at) }
+        assert_equal 5, Sidekiq.redis { |c| c.zcard('schedule') }
+      end
     end
 
-    class CustomUniqueWorker
-      include Sidekiq::Worker
-      sidekiq_options queue: :custom_unique_queue, unique: :all, manual: true
+    describe 'when unique option is enabled (unique: :all)' do
+      class UniqueScheduledWorker
+        include Sidekiq::Worker
+        sidekiq_options queue: :unique_scheduled_queue, unique: :all
 
-      def self.lock(id, unlock)
-        "custom:unique:lock:#{id}"
+        def perform(x)
+        end
       end
 
-      def self.unlock!(id, unlock)
-        lock = self.lock(id, unlock)
-        Sidekiq.redis { |conn| conn.del(lock) }
+      it 'does not duplicate scheduled messages' do
+        5.times { |t| UniqueScheduledWorker.perform_in((t+1)*60, 'args') }
+        assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
       end
 
-      def perform(id, unlock)
-        self.class.unlock!(id, unlock) if unlock
-        CustomUniqueWorker.perform_in(60, id, unlock)
+      it 'does correctly handle adding to the worker queue when scheduled' do
+        start_time = Time.now - 60
+        queue_time = start_time + 30
+        Timecop.travel start_time do
+          UniqueScheduledWorker.perform_at queue_time, 'x'
+        end
+        assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
+        assert_equal 0, Sidekiq.redis { |c| c.llen('queue:unique_scheduled_queue') }
+        Sidekiq::Scheduled::Poller.new.poll
+        assert_equal 0, Sidekiq.redis { |c| c.zcard('schedule') }
+        assert_equal 1, Sidekiq.redis { |c| c.llen('queue:unique_scheduled_queue') }
       end
-    end
 
-    it 'does not duplicate messages with enabled unique option and custom unique lock key' do
-      5.times { CustomUniqueWorker.perform_async('args', false) }
-      assert_equal 1, Sidekiq.redis { |c| c.llen('queue:custom_unique_queue') }
-      job = Sidekiq.load_json Sidekiq.redis { |c| c.lpop('queue:custom_unique_queue') }
-      assert job['jid']
-      assert_equal job['jid'], Sidekiq.redis { |c| c.get('custom:unique:lock:args') }
-    end
+      it 'allows the job to be re-scheduled after processing' do
+        # Schedule
+        5.times { |t| UniqueScheduledWorker.perform_in((t+1)*60, 'args') }
+        assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
 
-    it 'does not allow the job to be duplicated when processing job with manual option' do
-      5.times {
-        msg = Sidekiq.dump_json('class' => CustomUniqueWorker.to_s, 'args' => ['something', false])
+        # Process
+        msg = Sidekiq.dump_json('class' => UniqueScheduledWorker.to_s, 'queue' => 'unique_scheduled_queue', 'args' => ['args'])
         actor = MiniTest::Mock.new
         actor.expect(:processor_done, nil, [@processor])
         actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
         2.times { @boss.expect(:async, actor, []) }
         work = UnitOfWork.new('default', msg)
         @processor.process(work)
-      }
-      assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
-    end
 
-    it 'discards non critical information about the message' do
-      5.times {|i|
-        msg = Sidekiq.dump_json('class' => CustomUniqueWorker.to_s, 'args' => ['something', false], 'sent_at' => (Time.now + i*60).to_f)
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-        work = UnitOfWork.new('default', msg)
-        @processor.process(work)
-      }
-      assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
+        # Re-schedule
+        5.times { |t| UniqueScheduledWorker.perform_in((t+1)*60, 'args') }
+        assert_equal 2, Sidekiq.redis { |c| c.zcard('schedule') }
+      end
     end
 
-    it 'allows a job to be rescheduled when processing using unlock' do
-      5.times {
-        msg = Sidekiq.dump_json('class' => CustomUniqueWorker.to_s, 'args' => ['something', true])
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-        work = UnitOfWork.new('default', msg)
-        @processor.process(work)
-      }
-      assert_equal 5, Sidekiq.redis { |c| c.zcard('schedule') }
-    end
+    describe 'when unique and manual options are enabled (unique: :all, manual: true)' do
+      class CustomUniqueWorker
+        include Sidekiq::Worker
+        sidekiq_options queue: :custom_unique_queue, unique: :all, manual: true
+
+        def self.lock(id, unlock)
+          "custom:unique:lock:#{id}"
+        end
+
+        def self.unlock!(id, unlock)
+          lock = self.lock(id, unlock)
+          Sidekiq.redis { |conn| conn.del(lock) }
+        end
 
+        def perform(id, unlock)
+          self.class.unlock!(id, unlock) if unlock
+          CustomUniqueWorker.perform_in(60, id, unlock)
+        end
+      end
+
+      it 'does not duplicate messages with custom unique lock key' do
+        5.times { CustomUniqueWorker.perform_async('args', false) }
+        assert_equal 1, Sidekiq.redis { |c| c.llen('queue:custom_unique_queue') }
+        job = Sidekiq.load_json Sidekiq.redis { |c| c.lpop('queue:custom_unique_queue') }
+        assert job['jid']
+        assert_equal job['jid'], Sidekiq.redis { |c| c.get('custom:unique:lock:args') }
+      end
+
+      it 'does not allow the job to be duplicated when processing job' do
+        5.times {
+          msg = Sidekiq.dump_json('class' => CustomUniqueWorker.to_s, 'args' => ['something', false])
+          actor = MiniTest::Mock.new
+          actor.expect(:processor_done, nil, [@processor])
+          actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
+          2.times { @boss.expect(:async, actor, []) }
+          work = UnitOfWork.new('default', msg)
+          @processor.process(work)
+        }
+        assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
+      end
+
+      it 'discards non critical information about the message' do
+        5.times {|i|
+          msg = Sidekiq.dump_json('class' => CustomUniqueWorker.to_s, 'args' => ['something', false], 'sent_at' => (Time.now + i*60).to_f)
+          actor = MiniTest::Mock.new
+          actor.expect(:processor_done, nil, [@processor])
+          actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
+          2.times { @boss.expect(:async, actor, []) }
+          work = UnitOfWork.new('default', msg)
+          @processor.process(work)
+        }
+        assert_equal 1, Sidekiq.redis { |c| c.zcard('schedule') }
+      end
+
+      it 'allows a job to be rescheduled when processing using unlock' do
+        5.times {
+          msg = Sidekiq.dump_json('class' => CustomUniqueWorker.to_s, 'args' => ['something', true])
+          actor = MiniTest::Mock.new
+          actor.expect(:processor_done, nil, [@processor])
+          actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
+          2.times { @boss.expect(:async, actor, []) }
+          work = UnitOfWork.new('default', msg)
+          @processor.process(work)
+        }
+        assert_equal 5, Sidekiq.redis { |c| c.zcard('schedule') }
+      end
+    end
   end
 end

metadata

@@ -1,89 +1,89 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-middleware
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Dmitry Krasnoukhov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-08 00:00:00.000000000 Z
+date: 2014-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.12.4
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.12.4
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Additional sidekiq middleware
@@ -93,8 +93,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - CHANGES.md
 - Gemfile
 - LICENSE
@@ -105,8 +105,8 @@ files:
 - lib/sidekiq-middleware/core_ext.rb
 - lib/sidekiq-middleware/middleware.rb
 - lib/sidekiq-middleware/server/unique_jobs.rb
-- lib/sidekiq-middleware/unique_key.rb
 - lib/sidekiq-middleware/version.rb
+- lib/sidekiq-middleware/worker.rb
 - sidekiq-middleware.gemspec
 - test/helper.rb
 - test/test_core_ext.rb
@@ -120,17 +120,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0.rc.1
 signing_key: 
 specification_version: 4
 summary: Additional sidekiq middleware

data/lib/sidekiq-middleware/unique_key.rb

@@ -1,14 +0,0 @@
-module Sidekiq
-  module Middleware
-    module UniqueKey
-      def self.generate(worker_class, payload)
-        if worker_class.respond_to?(:lock)
-          worker_class.lock(*payload['args'])
-        else
-          json = Sidekiq.dump_json(payload)
-          "locks:unique:#{Digest::MD5.hexdigest(json)}"
-        end
-      end
-    end
-  end
-end