ar-resque-counter-cache 3.0.2 → 3.1.0

data/README.md

@@ -18,11 +18,15 @@ How does ar-resque-counter-cache address these issues? It uses Redis as a
 temporary counter cache and Resque to actually update the counter cache column
 sometime in the future. For example, let's say a single Post gets 1000 comments
 very quickly. This will set a key in Redis indicating that there is a delta of
-+1000 for that Post's comments_count column. It will also queue 1000 Resque
-jobs. This is where resque-lock-timeout comes in. Only one of those jobs will
-be allowed to run at a time. Once a job acquires the lock it removes all other
-instances of that job from the queue (see
-IncrementCountersWorker.around\_perform\_lock1).
++1000 for that Post's comments_count column. Previously (in versions 3.0.2 and
+below), it would also queue 1000 Resque jobs. This is where resque-lock-timeout
+came in. Only one of those jobs will be allowed to run at a time. Once a job
+acquires the lock it removes all other instances of that job from the queue
+(see IncrementCountersWorker.around\_perform\_lock1) using Redis's lrem
+command. Unfortunately we ran into some giant Redis cpu overload with lrems
+during traffic spikes and decided to switch to the simpler resque-loner gem.
+This gem instead uses a key to determine whether or not to enqueue a given job
+in the first place.
 
 You use it like such:
 

data/ar-resque-counter-cache.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Aaron Gibralter"]
   s.email       = ["aaron.gibralter@gmail.com"]
   s.homepage    = "http://github.com/agibralter/ar-resque-counter-cache"
-  s.summary     = %q{Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-lock-timeout).}
-  s.description = %q{Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-lock-timeout).}
+  s.summary     = %q{Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-loner).}
+  s.description = %q{Increment ActiveRecord's counter cache column asynchronously using Resque (and resque-loner).}
 
   s.rubyforge_project = "ar-resque-counter-cache"
 
@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency "activerecord", "~> 3.2"
   s.add_dependency "resque", "~> 1.0"
-  s.add_dependency "resque-lock-timeout", "~> 0.4"
+  s.add_dependency "resque-loner", "~> 1.2"
 
   s.add_development_dependency "rspec", "~> 2.4.0"
   s.add_development_dependency "sqlite3-ruby", "~> 1.3.3"

data/lib/ar-resque-counter-cache/increment_counters_worker.rb

@@ -1,5 +1,5 @@
 require 'resque'
-require 'resque-lock-timeout'
+require 'resque-loner'
 
 module ArResqueCounterCache
 
@@ -10,13 +10,6 @@ module ArResqueCounterCache
     end
   end
 
-  # The default lock_timeout is 60 seconds.
-  def self.resque_lock_timeout=(lock_timeout)
-    IncrementCountersWorker.class_eval do
-      @lock_timeout = lock_timeout
-    end
-  end
-
   # If you don't want to use Resque's Redis connection to store the temporary
   # counter caches, you can set a different connection here.
   def self.redis=(redis)
@@ -26,14 +19,13 @@ module ArResqueCounterCache
   end
 
   # ArResqueCounterCache will very quickly increment a counter cache in Redis,
-  # which will then later be updated by a Resque job. Using
-  # require-lock-timeout, we can ensure that only one job per ___ is running
-  # at a time.
+  # which will then later be updated by a Resque job. Using require-loner, we
+  # can ensure that only one job per payload is enqueued at a time.
   class IncrementCountersWorker
 
-    extend ::Resque::Plugins::LockTimeout
+    include Resque::Plugins::UniqueJob
     @queue = :counter_caches
-    @lock_timeout = 60
+    @loner_ttl = 3600 # Don't hold lock for more than 1 hour...
 
     def self.cache_and_enqueue(parent_class, id, column, direction)
       parent_class = parent_class.to_s
@@ -57,35 +49,11 @@ module ArResqueCounterCache
       args.join('-')
     end
 
-    # Try again later if lock is in use.
-    def self.lock_failed(*args)
-      ::Resque.enqueue(self, *args)
-    end
-
     # args: (parent_class, id, column)
     def self.cache_key(*args)
       "ar-resque-counter-cache:#{identifier(*args)}"
     end
 
-    # The name of this method ensures that it runs within around_perform_lock.
-    #
-    # We've leveraged resque-lock-timeout to ensure that only one job is
-    # running at a time. Now, this around filter essentially ensures that only
-    # one job per parent-column can sit on the queue at once. Since the
-    # cache_key entry in redis stores the most up-to-date delta for the
-    # parent's counter cache, we don't have to actually perform the
-    # Klass.update_counters for every increment/decrement. We can batch
-    # process!
-    def self.around_perform_lock1(*args)
-      # Remove all other instances of this job (with the same args) from the
-      # queue. Uses LREM (http://code.google.com/p/redis/wiki/LremCommand) which
-      # takes the form: "LREM key count value" and if count == 0 removes all
-      # instances of value from the list.
-      redis_job_value = ::Resque.encode(:class => self.to_s, :args => args)
-      ::Resque.redis.lrem("queue:#{@queue}", 0, redis_job_value)
-      yield
-    end
-
     def self.perform(parent_class, id, column)
       key = cache_key(parent_class, id, column)
       if (delta = redis.getset(key, 0).to_i) != 0

data/lib/ar-resque-counter-cache/version.rb

@@ -1,3 +1,3 @@
 module ArResqueCounterCache
-  VERSION = '3.0.2'
+  VERSION = '3.1.0'
 end

data/spec/integration_spec.rb

@@ -24,9 +24,9 @@ describe "integration" do
     @post2.count_of_comments.should == 0
 
     # 2 for posts incrementing users' posts counts
-    # 3 for comments incrementing users' comments counts
-    # 3 for comments incrementing posts' comments counts
-    Resque.size(:testing).should == 8
+    # 1 for comments incrementing users' comments counts
+    # 2 for comments incrementing posts' comments counts
+    Resque.size(:testing).should == 5
 
     # [ArResqueCounterCache::IncrementCountersWorker, "User", 1, "posts_count"]
     perform_next_job

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ar-resque-counter-cache
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-27 00:00:00.000000000 Z
+date: 2013-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,13 +44,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: resque-lock-timeout
+  name: resque-loner
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -92,7 +92,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.3.3
 description: Increment ActiveRecord's counter cache column asynchronously using Resque
-  (and resque-lock-timeout).
+  (and resque-loner).
 email:
 - aaron.gibralter@gmail.com
 executables: []
@@ -138,7 +138,7 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Increment ActiveRecord's counter cache column asynchronously using Resque
-  (and resque-lock-timeout).
+  (and resque-loner).
 test_files:
 - spec/ar_resque_counter_cache/active_record_spec.rb
 - spec/integration_spec.rb