capacitor 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: 6dde6d41727f6f92057212601934f5909528fa82
+  data.tar.gz: 30aa52c8a78d564be08dc3adf12d52b8e72e4239
+!binary "U0hBNTEy":
+  metadata.gz: 7edadb27faa727afd913a5b689a718ac4d9147b3b811467ac9e9623899a4829a9752dc5afac072ab030135bdc5208e6dda41c5bd3bd959f88c107fc68eaed3ae
+  data.tar.gz: 9a412459d55b87a2a33d2fabc46a5d5f0f5e8a3b0f5945f048e9d9f9c0c7848f1d7202564bddcc142ad160cbc96a44f13bf578f83fc735d1381ba1077514e686

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+script: bundle exec rake
+
+notifications:
+  email: false
+  hipchat:
+   - secure: "D/ppHWW3ZnaTSq/mtlZx+Vg96QksJN0igrpJVw808ERLX1WUyF44Vwo4ED8D\nbpppQBjhoUqbDM0mgD3Hb6b3mo//n84WXqzV5pfRnLLQM/9y7dzQcYers++9\ncwQwJw7WBu7J/m2yTV7qL4O6yPNB9YlYqIbum1jNbM5oKjksfTw="

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in capacitor.gemspec
+gemspec
+
+group :development do
+  gem 'guard-rspec'
+end
+

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'rspec', all_on_start: false, all_after_pass: false do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  watch(%r{^lib/(.+)\.rb$})                 { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^spec/support/(.+)\.rb$})        { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jesse Montrose
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+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.

data/README.md

@@ -0,0 +1,68 @@
+# Capacitor
+
+Keeping a counter cache field of a foreign table relationship can significantly reduce the DB cost of reading those counts later.  But what if your traffic patterns have you choking on a pile of counter updates to the same row?
+
+Instead of making ActiveRecord calls to change a counter field, write them to `Capacitor`.  They'll get summarized in a `redis` hash, with a separate process batch-retrieving and writing to `ActiveRecord`.  Being single-threaded, the writing process avoids row lock collisions, and absorbs traffic spikes by coalescing changes to the same row into one DB write.
+
+You get the high writing capacity of `redis`, the safety of your primary DB remaining the source-of-truth for the counts, and near-realtime counter field reads that don't require `COUNT(*)` queries.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'capacitor'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capacitor
+
+Also, both the injecting and listening ends of Capacitor will instantiate a bare `Redis.new` and require the appropriate `redis` environment variables.
+
+## Usage
+
+Increment and decrement changes flow in one direction:
+
+    ActiveRecord write > Capacitor Injector > redis > Capacitor Listener > DB
+
+### ActiveRecord write
+
+To buffer the 'users_count' field of your 'Widget' ActiveRecord model, add a method that calls `Capacitor.enqueue_count_change` with the `classname`, `object_id`, and a positive or negative increment.
+
+    def enqueue_users_count_change(delta)
+        Capacitor.enqueue_count_change 'Widget', widget_id, :users_count, delta
+    end
+
+### Capacitor Injector
+
+Writes go to `redis`, incrementing or decrementing the `capacitor:incoming_hash[classname:object_id:fieldname]` key.  The same value is pushed onto `capacitor.incoming_signal_list` to wake up the `Capacitor Listener`.
+
+### redis
+
+Changes build indefinitely in `capacitor:incoming_hash`.  `Capacitor` tries to avoid losing changes one time by moving improperly-processed batches (such as a crashing server) to `capacitor:retry_hash`.  After a second failure, batches are moved to `capacitor:failure:<timestamp>` and that failure key is added to `capacitor:failed_hash_keys`.
+
+### Capacitor Listener
+
+In order to ensure changes get written, you'll need to keep a listener running, such as in your `Procfile`:
+
+    capacitor: bundle exec rails runner "capacitor.run"
+
+`Capacitor.loop_forever` blocks indefinitely on `capacitor.incoming_signal_list` waiting for counter changes.  
+
+On waking, it sets aside the `capacitor:incoming_hash` to allow a new batch to start.  
+
+### DB
+
+Once a batch is set aside, `Capacitor Listener` loops over the `classname:object_id:fieldname` keys, trying to instantiate the `ActiveRecord` models and update their counts.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+task :default => [:spec]
+
+require 'rspec/core/rake_task'
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end

data/capacitor.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'capacitor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "capacitor"
+  spec.version       = Capacitor::VERSION
+  spec.authors       = ["Jesse Montrose"]
+  spec.email         = ["jesse@ninth.org"]
+  spec.description   = %q{Instead of making ActiveRecord calls to change a counter field, write them to capacitor.  They'll get summarized in a redis hash, with a separate process batch-retrieving and writing to ActiveRecord.  Being single-threaded, the writing process avoids row lock collisions, and absorbs traffic spikes by coalescing changes to the same row into one DB write.}
+  spec.summary       = %q{Buffered ActiveRecord counter writes through redis.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_dependency "formatted-metrics", "~> 1.0"
+  spec.add_dependency "redis-namespace", "~> 1.0"
+  spec.add_dependency "activesupport", "~> 3.2"
+
+  spec.add_development_dependency "activerecord", "~> 3.2"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "redis"
+  spec.add_development_dependency "rspec"
+end

data/lib/capacitor.rb

@@ -0,0 +1,42 @@
+require 'redis'
+require 'redis-namespace'
+require 'logger'
+require 'capacitor/railtie' if defined?(::Rails)
+
+module Capacitor
+  autoload :CounterCache, 'capacitor/counter_cache'
+  autoload :CommandsFetcher, 'capacitor/commands_fetcher'
+  autoload :Watcher, 'capacitor/watcher'
+  autoload :Updater, 'capacitor/updater'
+
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= const_defined?(:Rails) ? Rails.logger : Logger.new(STDOUT)
+    end
+
+    def log_level=(level)
+      return unless level
+      begin
+        level = Logger.const_get level.upcase if level.is_a?(String)
+        logger.level = level
+      rescue Exception => e
+        logger.error "Unable to set log level to #{level} - #{e}"
+      end
+    end
+
+    def redis=(redis)
+      @redis = Redis::Namespace.new :capacitor, redis: redis
+    end
+
+    def redis
+      @redis ||= Redis::Namespace.new :capacitor, redis: Redis.current
+    end
+
+    def run
+      STDOUT.sync = true
+      Watcher.run
+    end
+  end
+end

data/lib/capacitor/cli.rb

@@ -0,0 +1,13 @@
+require 'thor'
+
+module Capacitor
+  class CLI < Thor
+    include Thor::Actions
+
+    desc 'start', 'Run the capacitor'
+
+    def start
+      Capacitor.run
+    end
+  end
+end

data/lib/capacitor/commands_fetcher.rb

@@ -0,0 +1,86 @@
+module Capacitor
+
+  class CommandsFetcher
+
+    def fetch
+      new.retrieve_batch
+    end
+
+    def blocking_timeout
+      60
+    end
+
+    def redis
+      Capacitor.redis
+    end
+
+    def logger
+      Capacitor.logger
+    end
+
+    def incoming_signal_list
+      redis.blpop "incoming_signal_list", blocking_timeout
+    end
+
+    def block_on_incoming_signal_list
+      false until incoming_signal_list
+      flush_incoming_signal_list
+    end
+
+    def flush_incoming_signal_list
+      redis.del "incoming_signal_list"
+    end
+
+    def retrieve_existing_batch
+      batch = redis.hgetall "processing_hash"
+      if !batch.empty?
+        redis.rename "processing_hash", "retry_hash"
+        logger.error "processing_hash moved to retry_hash"
+        batch
+      else
+        nil
+      end
+    end
+
+    def retrieve_current_batch
+      begin
+        result = redis.rename "incoming_hash", "processing_hash"
+      rescue Exception => e
+        # This means we got a signal without getting data, which is
+        # probably okay due to the harmless race condition, but might
+        # warrant investigation later, so let's log it and move on.
+        logger.warn "empty incoming_hash in retrieve_batch"
+        return {}
+      end
+      redis.hgetall "processing_hash"
+    end
+
+    # When things are working well
+    # :incoming_hash -> :processing_hash -> flush()
+    #
+    # If a batch fails once
+    # :processing_hash -> :retry_hash -> flush()
+    #
+    # If a batch fails again
+    # :retry_hash -> :failed_hash_keys -> flush()
+    # then start over with :incoming_hash
+    def retrieve_batch
+      flush_retried_batch
+      return retrieve_existing_batch || retrieve_current_batch
+    end
+
+    def flush_batch
+      # Safely processed now, kill the batch in redis
+      redis.del "processing_hash", "retry_hash"
+    end
+
+    def flush_retried_batch
+      if redis.hlen("retry_hash") > 0
+        failure = 'failure:' + Time.new.utc.to_f.to_s
+        redis.rename "retry_hash", failure
+        redis.lpush "failed_hash_keys", failure
+        logger.error "retry_hash moved to #{failure}"
+      end
+    end
+  end
+end

data/lib/capacitor/counter_cache.rb

@@ -0,0 +1,54 @@
+module Capacitor
+  # Public: The public interface to incrementing and decrementing the counter cache
+  #
+  # klass  - ActiveRecord class
+  # id     - record id
+  # column - counter column symbol
+  class CounterCache
+    def initialize(klass, id, column)
+      @classname = klass.to_s
+      @id = id.to_s
+      @column = column
+    end
+
+    # Public: increment `column` by 1
+    #
+    # Returns: nothing
+    def increment
+      enqueue_count_change 1
+    end
+
+    # Public: decrement `column` by 1
+    #
+    # Returns: nothing
+    def decrement
+      enqueue_count_change -1
+    end
+
+  private
+
+    attr_accessor :classname, :id, :column
+
+    def redis
+      Capacitor.redis
+    end
+
+    def logger
+      Capacitor.logger
+    end
+
+    def enqueue_count_change(delta)
+      responses = redis.pipelined do
+        redis.hincrby "incoming_hash", counter_id, delta
+        redis.lpush "incoming_signal_list", counter_id
+        redis.get "log_level"
+      end
+      Capacitor.log_level= responses.last
+      logger.debug "enqueue_count_change #{counter_id} #{delta}"
+    end
+
+    def counter_id
+      [classname, id, column.to_s].join(':')
+    end
+  end
+end

data/lib/capacitor/railtie.rb

@@ -0,0 +1,7 @@
+module Capacitor
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.expand_path('../tasks.rb', __FILE__)
+    end
+  end
+end

data/lib/capacitor/tasks.rb

@@ -0,0 +1,5 @@
+namespace :capacitor do
+  task :run => :environment do
+    Capacitor.run
+  end
+end

data/lib/capacitor/updater.rb

@@ -0,0 +1,37 @@
+module Capacitor
+  class Updater
+    attr_reader :model, :id, :field, :count_delta, :counter_id
+
+    def initialize(counter_id, count_delta)
+      @count_delta = count_delta.to_i
+      @counter_id = counter_id
+      @model, @id, @field = self.class.parse_counter_id(counter_id)
+    end
+
+    # Public: Updates the counter with the new count delta
+    #
+    # If count_delta is zero, does nothing
+    def update
+      return if count_delta.zero?
+      model.update_counters(id, field => count_delta)
+    end
+
+    # Public: Returns the counter value from the database
+    def old_count
+      model.find(id)[field]
+    end
+
+    # Public: Returns a string of useful debug info
+    def inspect
+      "counter_id=#{counter_id} old_count=#{old_count} count_delta=#{count_delta}"
+    end
+
+    # Internal: Expect a counter_id in the form: classname:object_id:field_name
+    #
+    # Returns: model, object_id, :field
+    def self.parse_counter_id(counter_id)
+      classname, object_id, field_name = counter_id.split(':')
+      [classname.constantize, object_id.to_i, field_name.to_sym]
+    end
+  end
+end

data/lib/capacitor/version.rb

@@ -0,0 +1,3 @@
+module Capacitor
+  VERSION = "1.0.0"
+end

data/lib/capacitor/watcher.rb

@@ -0,0 +1,133 @@
+require "active_support/core_ext/string/inflections"
+require 'formatted-metrics'
+
+module Capacitor
+  class Watcher
+
+    def loop_forever
+      logger.info "Capacitor listening..."
+      redis.set "capacitor_start", Time.new.to_s
+
+      loop do
+        wait_for_batch
+        loop_once
+      end
+    end
+
+    def wait_for_batch
+      commands_fetcher.block_on_incoming_signal_list
+    end
+
+    def loop_once
+      @working = true
+      start_time = Time.new
+      Capacitor.log_level= log_level
+      counts = commands_fetcher.retrieve_batch
+      with_pause
+      process_batch counts
+      commands_fetcher.flush_batch
+
+      instrument "capacitor.loop.time", Time.new - start_time, units:'seconds'
+      instrument "capacitor.loop.object_counters", counts.length
+
+      shut_down! if shut_down?
+    ensure
+      @working = false
+    end
+
+    def with_pause
+      yield if block_given?
+
+      if time = pause_time
+        logger.debug "Capacitor pausing for #{time}s"
+        sleep time
+      end
+    end
+
+    def pause_time
+      time = redis.get "pause_time"
+      time ? time.to_f : nil
+    end
+
+    def log_level
+      redis.get "log_level"
+    end
+
+    def commands_fetcher
+      @commands_fetcher ||= CommandsFetcher.new
+    end
+
+    def self.run
+      watcher = new
+
+      %w(INT TERM).each do |signal|
+        trap signal do
+          watcher.handle_signal(signal)
+        end
+      end
+
+      watcher.loop_forever
+    end
+
+    def logger
+      Capacitor.logger
+    end
+
+    # Public: update_counters on models
+    #
+    # counts - {'classname:id:field_name' => increment, ...}
+    #
+    # Returns: nothing
+    def process_batch(counts)
+      counts.each do |counter_id, count_delta|
+        process(counter_id, count_delta)
+      end
+    end
+
+    # Public: Updates a counter on one model
+    def process(counter_id, count_delta)
+      updater = Updater.new(counter_id, count_delta)
+      logger.debug updater.inspect if logger.debug?
+      updater.update
+    rescue Exception => e
+      logger.error "#{counter_id} exception: #{e}"
+    end
+
+    def handle_signal(signal)
+      case signal
+      when 'INT', 'TERM'
+        working? ? shut_down : shut_down!
+      end
+    end
+
+    private
+
+    def working?
+      @working
+    end
+
+    def shut_down
+      @shut_down = true
+    end
+
+    def shut_down!
+      exit(0)
+    end
+
+    def shut_down?
+      @shut_down
+    end
+
+    def delay_warning_threshold
+      0.003
+    end
+
+    def redis
+      Capacitor.redis
+    end
+
+    def instrument(*args, &block)
+      Metrics.instrument *args, &block
+    end
+  end
+end

data/spec/capacitor/commands_fetcher_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Capacitor::CommandsFetcher do
+  subject (:commands_fetcher) { described_class.new }
+
+  describe '#incoming_signal_list' do
+    context 'when incoming_signal_list has items' do
+      subject { commands_fetcher.incoming_signal_list }
+      before {
+        redis.lpush "incoming_signal_list", "abc"
+        commands_fetcher.stub blocking_timeout: 1
+      }
+      it { should_not be_nil }
+    end
+    context 'when incoming_signal_list is empty' do
+      subject { commands_fetcher.incoming_signal_list }
+      before { commands_fetcher.stub blocking_timeout: 1 }
+      it { should be_nil }
+    end
+  end
+
+  describe '#retrieve_existing_batch' do
+    context 'when unprocessed batch waiting' do
+      subject {
+        commands_fetcher.retrieve_batch
+        # Normally, the retrieved batch would get flushed before a new retrieval
+        commands_fetcher.retrieve_existing_batch
+      }
+      before { redis.hincrby "incoming_hash", "Post:123:users_count", 1 }
+      it { should eq("Post:123:users_count" => "1") }
+    end
+  end
+
+  describe '#retrieve_batch' do
+    context 'when normal batch waiting' do
+      subject { commands_fetcher.retrieve_batch }
+      before { redis.hincrby "incoming_hash", "Post:123:users_count", 1 }
+      it { should eq("Post:123:users_count" => "1") }
+    end
+    context 'when unprocessed batch fails' do
+      subject {
+        commands_fetcher.retrieve_batch
+        commands_fetcher.retrieve_batch
+        commands_fetcher.retrieve_batch
+      }
+      before { redis.hincrby "incoming_hash", "Post:123:users_count", 1 }
+      it { should eq({}) }
+    end
+  end
+
+
+  describe '#flush_batch' do
+    before {
+      redis.hincrby "incoming_hash", "Post:123:users_count", 1
+      commands_fetcher.retrieve_batch
+    }
+    it 'flushes redis.processing_hash' do
+      expect { commands_fetcher.flush_batch }.to change { redis.hlen "processing_hash" }.from(1).to(0)
+    end
+  end
+
+  describe '#flush_retried_batch' do
+    before {
+      redis.hincrby "incoming_hash", "Post:123:users_count", 1
+      commands_fetcher.retrieve_batch
+      commands_fetcher.retrieve_batch
+    }
+    it 'flushes redis.retry_hash' do
+      expect { commands_fetcher.flush_retried_batch }.to change { redis.hlen "retry_hash" }.from(1).to(0)
+    end
+  end
+end

data/spec/capacitor/counter_cache_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Capacitor::CounterCache do
+  let (:klass) { Post }
+  let (:id) { 123 }
+  let (:column) { :view_count }
+  subject (:counter_cache) { described_class.new klass, id, column }
+
+  describe '#increment' do
+    it 'adds one element to hash key in redis' do
+      expect { counter_cache.increment }.to change { redis.hlen('incoming_hash') }.from(0).to(1)
+    end
+    it 'adds one element to signal key in redis' do
+      expect { counter_cache.increment }.to change { redis.llen('incoming_signal_list') }.from(0).to(1)
+    end
+    it 'increments 123 Post key by 1' do
+      expect { counter_cache.increment }.to change {
+        redis.hget('incoming_hash', 'Post:123:view_count')
+      }.from(nil).to("1")
+    end
+  end
+  describe '#decrement' do
+    it 'adds one element to hash key in redis' do
+      expect { counter_cache.decrement }.to change { redis.hlen('incoming_hash') }.from(0).to(1)
+    end
+    it 'adds one element to signal key in redis' do
+      expect { counter_cache.decrement }.to change { redis.llen('incoming_signal_list') }.from(0).to(1)
+    end
+    it 'decrements 123 Post key by 1' do
+      expect { counter_cache.decrement }.to change {
+        redis.hget('incoming_hash', 'Post:123:view_count')
+      }.from(nil).to("-1")
+    end
+  end
+end

data/spec/capacitor/updater_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Capacitor::Updater do
+  let (:model) { Post }
+  let (:id) { 123 }
+  let (:field) { :view_count }
+  let (:count_delta) { 13 }
+  let (:counter_id) { 'Post:123:view_count' }
+  subject (:updater) { described_class.new( counter_id, count_delta ) }
+
+  describe '#attributes' do
+    its(:model) { should == model }
+    its(:id) { should == id }
+    its(:field) { should == field }
+    its(:counter_id) { should == 'Post:123:view_count' }
+    its(:count_delta) { should == 13 }
+  end
+
+  describe '#update' do
+    it 'should call #update_counters on the model' do
+      model.should_receive(:update_counters).with(id, field => count_delta)
+      updater.update
+    end
+  end
+
+  describe '#inspect' do
+    before { updater.should_receive(:old_count).and_return(1) }
+    its(:inspect) { should == 'counter_id=Post:123:view_count old_count=1 count_delta=13' }
+  end
+
+  describe '.parse_counter_id' do
+    context 'with counter_id Post:123:users_count' do
+      subject { described_class.parse_counter_id 'Post:123:users_count' }
+      it { should eq([Post, 123, :users_count]) }
+    end
+
+    it 'fails to parse counter_id MissingClassname:123:users_count' do
+      expect { described_class.parse_counter_id 'MissingClassname:123:users_count' }.to raise_error(NameError)
+    end
+  end
+
+end

data/spec/capacitor/watcher_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Capacitor::Watcher do
+  subject (:watcher) { described_class.new }
+
+  describe '#process_batch' do
+    it 'updates counters' do
+      Post.should_receive(:update_counters).with(123, {:users_count=>1})
+      watcher.process_batch({'Post:123:users_count' => 1})
+    end
+    it 'logs invalid model classnames' do
+      watcher.logger.should_receive(:error).with("MissingClassname:123:users_count exception: uninitialized constant MissingClassname")
+      watcher.process_batch({'MissingClassname:123:users_count' => 1})
+    end
+  end
+
+  describe '#loop_once' do
+    it 'updates counters' do
+      Post.should_receive(:update_counters).with(123, {:users_count=>1})
+      redis.hincrby "incoming_hash", "Post:123:users_count", 1
+      redis.lpush "incoming_signal_list", "abc"
+      watcher.loop_once
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'bundler/setup'
+Bundler.require
+
+def redis
+  Capacitor.redis
+end
+
+RSpec.configure do |config|
+  config.before do
+    redis.flushdb
+  end
+end
+
+Capacitor.logger = Logger.new nil
+
+class Post
+  def self.update_counters(*)
+  end
+
+  def self.find(*)
+    new
+  end
+
+  def [](*)
+    1
+  end
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: capacitor
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jesse Montrose
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: formatted-metrics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.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: redis
+  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: rspec
+  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: Instead of making ActiveRecord calls to change a counter field, write
+  them to capacitor.  They'll get summarized in a redis hash, with a separate process
+  batch-retrieving and writing to ActiveRecord.  Being single-threaded, the writing
+  process avoids row lock collisions, and absorbs traffic spikes by coalescing changes
+  to the same row into one DB write.
+email:
+- jesse@ninth.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- capacitor.gemspec
+- lib/capacitor.rb
+- lib/capacitor/cli.rb
+- lib/capacitor/commands_fetcher.rb
+- lib/capacitor/counter_cache.rb
+- lib/capacitor/railtie.rb
+- lib/capacitor/tasks.rb
+- lib/capacitor/updater.rb
+- lib/capacitor/version.rb
+- lib/capacitor/watcher.rb
+- spec/capacitor/commands_fetcher_spec.rb
+- spec/capacitor/counter_cache_spec.rb
+- spec/capacitor/updater_spec.rb
+- spec/capacitor/watcher_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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
+signing_key: 
+specification_version: 4
+summary: Buffered ActiveRecord counter writes through redis.
+test_files:
+- spec/capacitor/commands_fetcher_spec.rb
+- spec/capacitor/counter_cache_spec.rb
+- spec/capacitor/updater_spec.rb
+- spec/capacitor/watcher_spec.rb
+- spec/spec_helper.rb
+has_rdoc: