counter-cache 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65f431cac9a84b8abe458919608c07c66501c68e
-  data.tar.gz: c0582fc1f4d829fc50162ce50746b33fdf06f2c8
+  metadata.gz: 2f919c6ae2950453f8c265ef31e5f60cbe492c47
+  data.tar.gz: baaf7090d810fe10ced19ce76928ce5d911f250a
 SHA512:
-  metadata.gz: db21a9548ac98191ddf559ff962c78f221656998efbe5f1a0c2af14e153e7256647fa3f54bc4f00faa8b3d34b9feabd9f94d6f82410805b241eb3384593ba1a9
-  data.tar.gz: 8b4abafb442cbdedef2ddffae83ebc7d71a418dedbef791ad3f963abc7c039b45e44fa8d4d2d992514da60091e8d555932439555c319f33923ac0fc12271f5a4
+  metadata.gz: f800e2e2fd6dbd1c9c60a6dd9f9a91fd84f1b42960e961631e8e23ae9ed5dd849cd6b662bcecd9c46db8e0772e13c9576465c8ac0e5839552c466b3746131957
+  data.tar.gz: 38275d8b622ebe622e2106a1b8118a4cb89901409e740ee67611fc485479535127adb55e74b565f94b96eb478337619b2d1975a3d0306a75d679de6544050ab0

data/.travis.yml

@@ -1,6 +1,6 @@
 rvm:
-  - "1.9.3"
   - "2.1.1"
+  - "2.3.0"
 gemfile:
   - gemfiles/activerecord_3.gemfile
   - gemfiles/activerecord_4.0.gemfile

data/README.md

@@ -1,9 +1,25 @@
-# Counter::Cache
+# Counter::Cache 
 
-[![Build Status](https://travis-ci.org/wanelo/counter-cache.svg?branch=master)](https://travis-ci.org/wanelo/counter-cache)
+[![Gem Version](https://badge.fury.io/rb/counter-cache.png)](http://badge.fury.io/rb/ventable)
+[![Build Status](https://travis-ci.org/wanelo/counter-cache.svg?branch=master&fl)](https://travis-ci.org/wanelo/counter-cache)
+[![Code Climate](https://codeclimate.com/github/wanelo/counter-cache.png)](https://codeclimate.com/github/wanelo/counter-cache)
 
 Counting things is hard, counting them at scale is even harder, so control when things are counted. 
 
+Any time your application performs pagination, the underlying library probably issues a `select count(*) from ...` 
+request to the database, because all paginators need to know how many pages there are. This works on a small-to-medium
+dataset, and in an application with relatively low web traffic. But at high traffic volume, live counts saturate CPU on the 
+database server. This is because sorting typically happens on CPU of the database server, using a small amount of heap 
+RAM or even worse — using temp files, which grinds the disk IO to a hault.  Web requests become slower and 
+slower, start to pile up in various queues, and eventually saturate all of the app servers.
+There you are, the site is down. 
+
+This gem provides a solution that works at scale, and will help you keep your site up.
+
+This library is battle-tested at Wanelo, where it has been running for several years.
+
+### Overview 
+
 [Rails Counter Caches](http://railscasts.com/episodes/23-counter-cache-column) are a convenient way to keep counters on
 models that have many children. Without them, you always do live counts, which do not scale. But at high scale, Rails
 counter caches create update contention on singe models, especially for social sites where any single model might become
@@ -98,6 +114,19 @@ Counter caches are configured on the models from the perspective of the child mo
 
 #### Basic Counter with recalculation:
 
+```ruby
+class Post
+  include Counter::Cache
+
+  counter_cache_on column: :posts_count, # users.posts_count
+                   relation: :user,
+                   relation_class_name: "User",
+                   method: :calculate_posts_count # This is a method on the user.
+end
+```
+
+#### To allow a timestamp to be updated:
+
 ```ruby
 class Post
   include Counter::Cache
@@ -106,6 +135,7 @@ class Post
                    relation: :user,
                    relation_class_name: "User",
                    method: :calculate_posts_count, # This is a method on the user.
+                   touch_column: :posts_updated_at
 end
 ```
 

data/Rakefile

@@ -2,5 +2,9 @@ require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
-
 task :default => :spec
+task :all do
+  sh 'bundle exec appraisal install'
+  sh 'bundle exec appraisal rspec'
+end
+

data/gemfiles/activerecord_3.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    counter-cache (0.0.2)
+    counter-cache (0.3.0)
       activerecord (>= 3.0)
 
 GEM
@@ -90,3 +90,6 @@ DEPENDENCIES
   rake
   rspec (>= 3.0)
   sqlite3
+
+BUNDLED WITH
+   1.11.2

data/gemfiles/activerecord_4.0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    counter-cache (0.0.2)
+    counter-cache (0.3.0)
       activerecord (>= 3.0)
 
 GEM
@@ -96,3 +96,6 @@ DEPENDENCIES
   rake
   rspec (>= 3.0)
   sqlite3
+
+BUNDLED WITH
+   1.11.2

data/gemfiles/activerecord_4.1.gemfile.lock

@@ -1,84 +1,91 @@
 PATH
   remote: ../
   specs:
-    counter-cache (0.0.2)
+    counter-cache (0.3.0)
       activerecord (>= 3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.1.4)
-      activesupport (= 4.1.4)
+    activemodel (4.1.14.1)
+      activesupport (= 4.1.14.1)
       builder (~> 3.1)
-    activerecord (4.1.4)
-      activemodel (= 4.1.4)
-      activesupport (= 4.1.4)
+    activerecord (4.1.14.1)
+      activemodel (= 4.1.14.1)
+      activesupport (= 4.1.14.1)
       arel (~> 5.0.0)
-    activesupport (4.1.4)
+    activesupport (4.1.14.1)
       i18n (~> 0.6, >= 0.6.9)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
       thread_safe (~> 0.1)
       tzinfo (~> 1.1)
-    appraisal (1.0.0)
+    appraisal (2.1.0)
       bundler
       rake
       thor (>= 0.14.0)
     arel (5.0.1.20140414130214)
     builder (3.2.2)
-    celluloid (0.15.2)
-      timers (~> 1.1.0)
     coderay (1.1.0)
     diff-lcs (1.2.5)
     fakeredis (0.5.0)
       redis (~> 3.0)
-    ffi (1.9.3)
+    ffi (1.9.10)
     formatador (0.2.5)
-    guard (2.6.1)
+    guard (2.13.0)
       formatador (>= 0.2.4)
-      listen (~> 2.7)
+      listen (>= 2.7, <= 4.0)
       lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
       pry (>= 0.9.12)
+      shellany (~> 0.0)
       thor (>= 0.18.1)
-    guard-rspec (4.3.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.6.4)
       guard (~> 2.1)
-      rspec (>= 2.14, < 4.0)
-    i18n (0.6.11)
-    json (1.8.1)
-    listen (2.7.9)
-      celluloid (>= 0.15.2)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    listen (3.0.5)
       rb-fsevent (>= 0.9.3)
       rb-inotify (>= 0.9)
-    lumberjack (1.0.9)
+    lumberjack (1.0.10)
     method_source (0.8.2)
-    minitest (5.4.0)
-    pry (0.10.0)
+    minitest (5.8.4)
+    nenv (0.2.0)
+    notiffany (0.0.8)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.10.3)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
-    rake (10.3.2)
-    rb-fsevent (0.9.4)
+    rake (10.5.0)
+    rb-fsevent (0.9.7)
     rb-inotify (0.9.5)
       ffi (>= 0.5.0)
-    redis (3.1.0)
-    rspec (3.0.0)
-      rspec-core (~> 3.0.0)
-      rspec-expectations (~> 3.0.0)
-      rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.3)
-      rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.3)
+    redis (3.2.2)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.2)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.3)
-      rspec-support (~> 3.0.0)
-    rspec-support (3.0.3)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    shellany (0.0.1)
     slop (3.6.0)
-    sqlite3 (1.3.9)
+    sqlite3 (1.3.11)
     thor (0.19.1)
-    thread_safe (0.3.4)
-    timers (1.1.0)
-    tzinfo (1.2.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
       thread_safe (~> 0.1)
 
 PLATFORMS
@@ -95,3 +102,6 @@ DEPENDENCIES
   rake
   rspec (>= 3.0)
   sqlite3
+
+BUNDLED WITH
+   1.11.2

data/lib/counter/cache/counters/buffer_counter/enqueuer.rb

@@ -11,14 +11,16 @@ module Counter
           private
 
           def create_and_enqueue(delay, cached)
+            parameters = { relation_class_name: relation_class,
+                           relation_id: relation_id,
+                           column: options.column,
+                           method: options.method,
+                           cache: cached,
+                           counter: counter_class_name }
+            parameters[:touch_column] = options.touch_column unless options.touch_column.nil?
             options.worker_adapter.enqueue(delay,
                                            source_object_class_name,
-                                           { relation_class_name: relation_class,
-                                             relation_id: relation_id,
-                                             column: options.column,
-                                             method: options.method,
-                                             cache: cached,
-                                             counter: counter_class_name })
+                                           parameters)
           end
         end
       end

data/lib/counter/cache/counters/buffer_counter/saver.rb

@@ -18,6 +18,7 @@ module Counter
 
           def save_new_value!(value)
             relation_object.send("#{options.column}=", value)
+            relation_object.send("#{options.touch_column}=", DateTime.now) if options.touch_column
             relation_object.save!(validate: false)
           end
 

data/lib/counter/cache/options_parser.rb

@@ -13,6 +13,10 @@ module Counter
         options[:column]
       end
 
+      def touch_column
+        options[:touch_column]
+      end
+
       def relation
         options[:relation]
       end

data/lib/counter/cache/version.rb

@@ -1,5 +1,5 @@
 module Counter
   module Cache
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
   end
 end

data/spec/lib/counter/cache/buffer_counter/enqueuer_spec.rb

@@ -2,52 +2,106 @@ require 'spec_helper'
 
 RSpec.describe Counter::Cache::Counters::BufferCounter::Enqueuer do
   let(:worker_adapter) { double }
-  let(:options) { double(worker_adapter: worker_adapter,
-                         wait: 10,
-                         column: "boo",
-                         method: "calculate_boo",
-                         cached?: true,
-                         recalculation?: false,
-                         recalculation_delay: 20) }
 
   let(:source_object_class_name) { "BooUser" }
   let(:relation_id) { 1 }
   let(:relation_type) { "Boo" }
 
-  let(:enqueuer) { Counter::Cache::Counters::BufferCounter::Enqueuer.new(options, source_object_class_name, relation_id, relation_type, "SuperCounter") }
-
   describe '#enqueue' do
-    before do
-      expect(worker_adapter).to receive(:enqueue).with(10,
-                                                       "BooUser",
-                                                       { relation_class_name: "Boo",
-                                                         relation_id: 1,
-                                                         column: "boo",
-                                                         method: "calculate_boo",
-                                                         cache: true,
-                                                         counter: "SuperCounter" })
-    end
-
-    describe 'when recalculation is true' do
+    context "without touch column" do
       before do
-        expect(options).to receive(:recalculation?).and_return(true)
-      end
+        @options =  double(worker_adapter: worker_adapter,
+                           wait: 10,
+                           column: "boo",
+                           method: "calculate_boo",
+                           cached?: true,
+                           recalculation?: false,
+                           recalculation_delay: 20)
+
+        @enqueuer = Counter::Cache::Counters::BufferCounter::Enqueuer.new(@options, source_object_class_name, relation_id, relation_type, "SuperCounter")
 
-      it "enqueues two jobs" do
-        expect(worker_adapter).to receive(:enqueue).with(20,
+        expect(worker_adapter).to receive(:enqueue).with(10,
                                                          "BooUser",
                                                          { relation_class_name: "Boo",
                                                            relation_id: 1,
                                                            column: "boo",
                                                            method: "calculate_boo",
-                                                           cache: false,
+                                                           cache: true,
                                                            counter: "SuperCounter" })
-        enqueuer.enqueue!(double)
+      end
+
+      describe 'when recalculation is true' do
+        before do
+          expect(@options).to receive(:recalculation?).and_return(true)
+        end
+
+        it "enqueues two jobs" do
+          expect(@options).to receive(:touch_column).twice
+          expect(worker_adapter).to receive(:enqueue).with(20,
+                                                           "BooUser",
+                                                           { relation_class_name: "Boo",
+                                                             relation_id: 1,
+                                                             column: "boo",
+                                                             method: "calculate_boo",
+                                                             cache: false,
+                                                             counter: "SuperCounter" })
+          @enqueuer.enqueue!(double)
+        end
+      end
+
+      it 'enqueues one job' do
+        expect(@options).to receive(:touch_column)
+        @enqueuer.enqueue!(double)
       end
     end
 
-    it 'enqueues one job' do
-      enqueuer.enqueue!(double)
+    context "with touch column" do
+      before(:each) do
+        @options = double(worker_adapter: worker_adapter,
+                          wait: 10,
+                          column: "boo",
+                          touch_column: "boo_updated_at",
+                          method: "calculate_boo",
+                          cached?: true,
+                          recalculation?: false,
+                          recalculation_delay: 20)
+        @enqueuer = Counter::Cache::Counters::BufferCounter::Enqueuer.new(@options, source_object_class_name, relation_id, relation_type, "SuperCounter")
+
+        expect(worker_adapter).to receive(:enqueue).with(10,
+                                                         "BooUser",
+                                                         { relation_class_name: "Boo",
+                                                           relation_id: 1,
+                                                           column: "boo",
+                                                           touch_column: "boo_updated_at",
+                                                           method: "calculate_boo",
+                                                           cache: true,
+                                                           counter: "SuperCounter" })
+      end
+
+      describe 'when recalculation is true' do
+        before do
+          expect(@options).to receive(:recalculation?).and_return(true)
+        end
+
+        it "enqueues two jobs" do
+          expect(@options).to receive(:touch_column).exactly(4).times
+          expect(worker_adapter).to receive(:enqueue).with(20,
+                                                           "BooUser",
+                                                           { relation_class_name: "Boo",
+                                                             relation_id: 1,
+                                                             column: "boo",
+                                                             touch_column: "boo_updated_at",
+                                                             method: "calculate_boo",
+                                                             cache: false,
+                                                             counter: "SuperCounter" })
+          @enqueuer.enqueue!(double)
+        end
+      end
+
+      it 'enqueues one job' do
+        expect(@options).to receive(:touch_column)
+        @enqueuer.enqueue!(double)
+      end
     end
   end
 end

data/spec/lib/counter/cache/buffer_counter/saver_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Counter::Cache::Counters::BufferCounter::Saver do
   class Boo
   end
 
-  let(:relation_object) { double(boo_count: 2) }
+  let(:relation_object) { double(boo_count: 2, boo_updated_at: DateTime.now) }
   let(:options) { double(relation_class_name: "Boo", relation_id: 1, column: "boo_count", method: nil, source_object_class_name: Boo) }
   let(:saver) { Counter::Cache::Counters::BufferCounter::Saver.new(options) }
 
@@ -21,6 +21,7 @@ RSpec.describe Counter::Cache::Counters::BufferCounter::Saver do
 
       before do
         allow(options).to receive(:cached?).and_return(true)
+        allow(options).to receive(:touch_column).and_return(nil)
         expect(relation_object).to receive(:boo_count=).with(4)
         expect(relation_object).to receive(:save!)
         expect(counting_store).to receive(:del)
@@ -41,15 +42,29 @@ RSpec.describe Counter::Cache::Counters::BufferCounter::Saver do
         expect(counting_store).to receive(:del)
       end
 
-      it 'saves the value' do
-        expect(relation_object).to receive(:boo_count=).with(4)
-        expect(relation_object).to receive(:save!)
-        saver.save!
+      context "with touch column" do
+        it 'saves the value' do
+          allow(options).to receive(:touch_column).and_return(:boo_updated_at)
+          expect(relation_object).to receive(:boo_count=).with(4)
+          expect(relation_object).to receive(:boo_updated_at=).with(DateTime.now)
+          expect(relation_object).to receive(:save!)
+          saver.save!
+        end
+      end
+
+      context "without touch column" do
+        it 'saves the value' do
+          allow(options).to receive(:touch_column).and_return(nil)
+          expect(relation_object).to receive(:boo_count=).with(4)
+          expect(relation_object).to receive(:save!)
+          saver.save!
+        end
       end
     end
 
     describe 'when cached? is false' do
       before do
+        allow(options).to receive(:touch_column).and_return(nil)
         allow(options).to receive(:cached?).and_return(false)
       end
 

data/spec/lib/counter/cache/options_parser_spec.rb

@@ -34,6 +34,13 @@ RSpec.describe Counter::Cache::OptionsParser do
     end
   end
 
+  describe "#touch_column" do
+    let(:options) { { touch_column: "touch_column_name" } }
+    it "returns option if set" do
+      expect(parser.touch_column).to eq("touch_column_name")
+    end
+  end
+
   describe "#method" do
     let(:options) { { method: "method" } }
     it "returns option if set" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: counter-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Paul Henry & Matt Camuto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-16 00:00:00.000000000 Z
+date: 2016-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -207,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Counting is hard.