counters 1.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+dump.rdb

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in counters.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2009 François Beausoleil (francois@teksol.info)
+
+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.textile

@@ -0,0 +1,84 @@
+h1. Counters
+
+Easily record any metric from anywhere within your system. Metrics are recorded to Redis (using the provided backend), in a single Hash key. You can then extract the keys later and use them with Cacti to generate graphs about anything going on.
+
+h2. Sample Usage
+
+Let's say you have a crawler. You'd like to record the number of URLs you visit, the number of URLs you skipped due to 304 Not Modified responses, and the number of bytes you consumed, and the amount of time each page takes to process. Here's how you'd do that:
+
+<pre><code>require "counters"
+require "rest_client"
+Counter = Counters::Redis.new(Redis.new, "counters")
+
+while url = STDIN.gets
+  Counter.hit "crawler.urls"
+
+  response = RestClient.get(url)
+  Counter.magnitude "crawler.bytes.read", response.length
+  next Counter.hit "crawler.urls.skipped" if response.code == 304
+
+  Counter.latency "crawler.processing" do
+    # some long and complicated processing
+  end
+end
+</code></pre>
+
+Redis will have a single key, named counters here, with the following keys and values in it (after 1 call with a 200 response code):
+
+* hits.crawler.urls = 1
+* magnitudes.crawler.bytes.read = 2041
+* latencies.crawler.processing.count = 1
+* latencies.crawler.processing.nanoseconds = 381000000
+
+h2. Other Implementations
+
+For testing purposes, there also exists a <code>Counters::Memory</code>. This would be good in test mode, for example. The counters are exposed through accessor methods returning a Hash.
+
+For file logging, you should use <code>Counters::File</code>, which accepts a <code>String</code>, <code>IO</code> or <code>Logger</code> instance. All of these will be transformed to a <code>Logger</code> instance with a very strict format. All events will be logged to the file, one event per line.
+
+<pre><code>$ irb -r counters
+> Counter = Counters::File.new("counters.log")
+ => #<Counters::File:0x00000101a18f18 @logger=#<Logger:0x00000101a18ef0 @progname=nil, @level=0, @default_formatter=#<Logger::Formatter:0x00000101a18ea0 @datetime_format=nil>, @formatter=#<Proc:0x00000101a18bd0@/Users/francois/Projects/counters/lib/counters/file.rb:15 (lambda)>, @logdev=#<Logger::LogDevice:0x00000101a18e28 @shift_size=1048576, @shift_age=0, @filename="counters.log", @dev=#<File:counters.log>, @mutex=#<Logger::LogDevice::LogDeviceMutex:0x00000101a18e00 @mon_owner=nil, @mon_count=0, @mon_mutex=#<Mutex:0x00000101a18d88>>>>> 
+> Counter.hit "crawler.page_read"
+ => true 
+> Counter.magnitude "crawler.bytes_in", 9_921
+ => true 
+> Counter.latency "crawler.processing" do sleep 0.3 ; end
+ => true 
+> Counter.ping "crawler.alive"
+ => true 
+
+$ cat counters.log
+2011-02-21T09:46:21.296326000 - hit: crawler.page_read
+2011-02-21T09:46:24.280388000 - magnitude: crawler.bytes_in 9921
+2011-02-21T09:46:27.989183000 - latency: crawler.processing 0.3001821041107178s
+2011-02-21T09:46:31.031969000 - ping: crawler.alive
+2011-02-21T09:46:21.296326000 - hit: crawler.page_read
+2011-02-21T09:46:24.280388000 - magnitude: crawler.bytes_in 13291
+2011-02-21T09:46:27.989183000 - latency: crawler.processing 0.3123122982101s
+</code></pre>
+
+h2. LICENSE
+
+(The MIT License)
+
+Copyright (c) 2008-2009 François Beausoleil (francois@teksol.info)
+
+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/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new
+
+  task :default => :spec
+rescue LoadError
+  warn "RSpec not available - Rake tasks not available"
+  warn "Install rspec using: gem install rspec"
+end

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/counters.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "counters/version"
+
+Gem::Specification.new do |s|
+  s.name        = "counters"
+  s.version     = Counters::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["François Beausoleil"]
+  s.email       = ["francois@teksol.info"]
+  s.homepage    = ""
+  s.summary     = %q{Provides an API to record any kind of metrics within your system}
+  s.description = %q{Using the provided API, record metrics (such as number of hits to a particular controller, bytes in/out, compression ratio) within your system. Visualization is NOT provided within this gem.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "timecop"
+end

data/lib/counters.rb

@@ -0,0 +1,14 @@
+# A simple way to record performance counters / metrics.
+#
+# All performance counters can be broken down into a few categories:
+#
+# * +ping+ Just to know something is still alive. You'd probably graph "now() - ping".
+# * +hit+ Increments a counter. In this case you'd graph the 1st derivative, to see how the slope of changes.
+# * +latency+ Increments a counter representing time. You'd again graph the 1st derivative.
+# * +magnitude+ Sets a counter representing a value (bytes, free RAM, etc). Here you'd graph min, max, avg and stdev.
+module Counters
+  autoload :Base, "counters/base"
+  autoload :Redis, "counters/redis"
+  autoload :Memory, "counters/memory"
+  autoload :File, "counters/file"
+end

data/lib/counters/base.rb

@@ -0,0 +1,53 @@
+module Counters
+  class Base
+    def hit(key)
+      validate(key)
+      record_hit(key)
+    end
+
+    def magnitude(key, value)
+      validate(key)
+      record_magnitude(key, value)
+    end
+
+    def latency(key, time_in_seconds=nil)
+      validate(key)
+      if block_given? then
+        raise ArgumentError, "Must pass either a latency or a block, not both: received #{time_in_seconds.inspect} in addition to a block" if time_in_seconds
+        time_in_seconds = Benchmark.measure { yield }.real
+      end
+
+      record_latency(key, time_in_seconds)
+    end
+
+    def ping(key)
+      validate(key)
+      record_ping(key)
+    end
+
+    def record_hit(key)
+      raise "Subclass Responsibility Error: must be implemented in instances of #{self.class} but isn't"
+    end
+    protected :record_hit
+
+    def record_magnitude(key)
+      raise "Subclass Responsibility Error: must be implemented in instances of #{self.class} but isn't"
+    end
+    protected :record_magnitude
+
+    def record_latency(key)
+      raise "Subclass Responsibility Error: must be implemented in instances of #{self.class} but isn't"
+    end
+    protected :record_latency
+
+    def record_ping(key)
+      raise "Subclass Responsibility Error: must be implemented in instances of #{self.class} but isn't"
+    end
+    protected :record_ping
+
+    def validate(key)
+      key.to_s =~ /\A[.\w]+\Z/i or raise ArgumentError, "Keys can contain only letters, numbers, the underscore (_) and fullstop (.), received #{key.inspect}"
+    end
+    private :validate
+  end
+end

data/lib/counters/file.rb

@@ -0,0 +1,34 @@
+require "benchmark"
+require "logger"
+
+module Counters
+  class File < Counters::Base
+    def initialize(path_or_io_or_logger)
+      @logger = if path_or_io_or_logger.kind_of?(Logger) then
+                path_or_io_or_logger
+              elsif path_or_io_or_logger.respond_to?(:<<) then
+                Logger.new(path_or_io_or_logger)
+              else
+                raise ArgumentError, "Counters::File expects an object which is either a Logger or respond to #<<, received a #{path_or_io_or_logger.class}"
+              end
+
+      @logger.formatter = lambda {|severity, datetime, progname, msg| "#{datetime.strftime("%Y-%m-%dT%H:%M:%S.%N")} - #{msg}\n"}
+    end
+
+    def record_hit(key)
+      @logger.info "hit: #{key}"
+    end
+
+    def record_magnitude(key, magnitude)
+      @logger.info "magnitude: #{key} #{magnitude}"
+    end
+
+    def record_latency(key, time_in_seconds=nil)
+      @logger.info "latency: #{key} #{time_in_seconds}s"
+    end
+
+    def record_ping(key)
+      @logger.info "ping: #{key}"
+    end
+  end
+end

data/lib/counters/memory.rb

@@ -0,0 +1,30 @@
+require "counters"
+
+module Counters
+  class Memory < Counters::Base
+    attr_reader :hits, :latencies, :magnitudes, :pings
+
+    def initialize
+      @hits       = Hash.new {|h,k| h[k] = 0}
+      @magnitudes = Hash.new {|h,k| h[k] = 0}
+      @latencies  = Hash.new {|h,k| h[k] = Array.new}
+      @pings      = Hash.new
+    end
+
+    def record_hit(key)
+      @hits[key] += 1
+    end
+
+    def record_ping(key)
+      @pings[key] = Time.now
+    end
+
+    def record_latency(key, time_in_seconds)
+      @latencies[key] << time_in_seconds
+    end
+
+    def record_magnitude(key, value)
+      @magnitudes[key] = value
+    end
+  end
+end

data/lib/counters/redis.rb

@@ -0,0 +1,30 @@
+require "benchmark"
+require "counters"
+
+module Counters
+  class Redis < Counters::Base
+    def initialize(redis, base_key)
+      @redis, @base_key = redis, base_key
+    end
+
+    def record_hit(key)
+      @redis.hincrby(@base_key, "hits.#{key}", 1)
+    end
+
+    def record_magnitude(key, amount)
+      @redis.hset(@base_key, "magnitudes.#{key}", amount)
+    end
+
+    def ping(key)
+      @redis.hset(@base_key, "pings.#{key}", Time.now.to_i)
+    end
+
+    # Redis requires integer keys, thus we scale all latencies to the nanosecond precision
+    SCALING_FACTOR = 1_000_000_000
+
+    def record_latency(key, latency_in_seconds)
+      @redis.hincrby(@base_key, "latencies.#{key}.count", 1)
+      @redis.hincrby(@base_key, "latencies.#{key}.nanoseconds", (latency_in_seconds * SCALING_FACTOR).to_i)
+    end
+  end
+end

data/lib/counters/version.rb

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

data/spec/file_counter_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+require "logger"
+require "tempfile"
+
+describe Counters::File do
+  TIMESTAMP_RE = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3,}/
+
+  let :tempfile do
+    Tempfile.new("counters.log")
+  end
+
+  let :counter do
+    Counters::File.new(tempfile)
+  end
+
+  it_should_behave_like "all counters"
+
+  it "should log a message to the logfile when a hit is recorded" do
+    counter.hit "urls.visited"
+    tempfile.rewind
+    tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\shit.*urls\.visited$/
+  end
+
+  it "should log a message to the logfile when a magnitude is recorded" do
+    counter.magnitude "bytes.read", 2_013
+    tempfile.rewind
+    tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\smagnitude.*bytes\.read.*2013$/
+  end
+
+  it "should log a message to the logfile when a latency is recorded" do
+    counter.latency "processing", 0.132 # in seconds
+    tempfile.rewind
+    tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\slatency.*processing.*0.132s$/
+  end
+
+  it "should record a message in the logfile when a ping is recorded" do
+    counter.ping "crawler.alive"
+    tempfile.rewind
+    tempfile.read.should =~ /^#{TIMESTAMP_RE}\s-\sping.*crawler\.alive$/
+  end
+
+  it "should log a message to the logfile when a latency is recorded using a block" do
+    counter.latency "crawling" do
+      sleep 0.1
+    end
+
+    tempfile.rewind
+    tempfile.read.should =~ /latency.*crawling.*0.1\d+s/
+  end
+
+  it "should raise an ArgumentError when calling #latency with both a block and a latency" do
+    lambda { counter.latency("processing", 0.123) { sleep 0.1 } }.should raise_error(ArgumentError)
+  end
+
+  it "should accept a filename on instantiation" do
+    Counters::File.new("counters.log")
+  end
+
+  it "should accept a File instance on instantiation" do
+    Counters::File.new( File.open("counters.log", "w") )
+  end
+
+  it "should accept a Logger instance on instantiation" do
+    Counters::File.new( Logger.new("counters.log") )
+  end
+
+  it "should raise an ArgumentError when a bad type is used in the initializer" do
+    lambda { Counters::File.new(nil) }.should raise_error(ArgumentError)
+  end
+
+  after(:each) do
+    fname = File.dirname(__FILE__) + "/../counters.log"
+    File.unlink(fname) if File.exist?(fname)
+  end
+end

data/spec/memory_counter_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe Counters::Memory do
+  let :counter do
+    Counters::Memory.new
+  end
+
+  it_should_behave_like "all counters"
+
+  it "should record a hit with key 'pages.read'" do
+    counter.hit "pages.read"
+    counter.hits.should have_key("pages.read")
+    counter.hits["pages.read"].should == 1
+
+    counter.hit "pages.read"
+    counter.hits["pages.read"].should == 2
+  end
+
+  it "should record a ping with key 'processor.alive'" do
+    Timecop.freeze do
+      counter.ping "processor.alive"
+      counter.pings.should have_key("processor.alive")
+      counter.pings["processor.alive"].strftime("%Y-%m-%d %H:%M:%S").should == Time.now.strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    target_time = Time.now + 9
+    Timecop.travel(target_time) do
+      counter.ping "processor.alive"
+      counter.pings.should have_key("processor.alive")
+      counter.pings["processor.alive"].strftime("%Y-%m-%d %H:%M:%S").should == target_time.strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+
+  it "should record a latency with a passed value" do
+    counter.latency "processor.enqueue", 0.00012
+    counter.latencies["processor.enqueue"].should == [0.00012]
+
+    counter.latency "processor.enqueue", 0.00121
+    counter.latencies["processor.enqueue"].should == [0.00012, 0.00121]
+  end
+
+  it "should record a magnitude" do
+    counter.magnitude "processor.bytes_compressed", 9_312
+    counter.magnitude "processor.bytes_compressed", 8_271
+    counter.magnitudes["processor.bytes_compressed"].should == 8_271
+  end
+end

data/spec/redis_counter_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Counters::Redis do
+  let :redis do
+    double("redis")
+  end
+
+  let :counter do
+    Counters::Redis.new(redis, "counters")
+  end
+
+  it_should_behave_like "all counters"
+
+  it "should record a hit on 'pages.read' by HINCRBY counters/hits.pages.read" do
+    redis.should_receive(:hincrby).with("counters", "hits.pages.read", 1).twice
+    2.times { counter.hit "pages.read" }
+  end
+
+  it "should record a magnitude on 'bytes.in' by HSET counters/magnitudes.bytes.in" do
+    redis.should_receive(:hset).with("counters", "magnitudes.bytes.in", 309).once
+    redis.should_receive(:hset).with("counters", "magnitudes.bytes.in", 392).once
+    counter.magnitude "bytes.in", 309
+    counter.magnitude "bytes.in", 392
+  end
+
+  it "should record a ping on 'crawler' by HSET counters/pings.crawler with today's date/time as an int" do
+    Timecop.freeze do
+      redis.should_receive(:hset).with("counters", "pings.crawler", Time.now.utc.to_i).once
+      counter.ping "crawler"
+    end
+
+    target_time = Time.now + 9
+    Timecop.travel(target_time) do
+      redis.should_receive(:hset).with("counters", "pings.crawler", target_time.to_i).once
+      counter.ping "crawler"
+    end
+  end
+
+  it "should record latency on 'crawler.download' by HINCRBY counters/latencies.crawler.download.count by 1 and counters/latencies.crawler.download.nanoseconds by the latency" do
+    redis.should_receive(:hincrby).with("counters", "latencies.crawler.download.count", 1).twice
+    redis.should_receive(:hincrby).with("counters", "latencies.crawler.download.nanoseconds", 1.90 * 1_000_000_000).once
+    redis.should_receive(:hincrby).with("counters", "latencies.crawler.download.nanoseconds", 2.02 * 1_000_000_000).once
+
+    counter.latency "crawler.download", 1.9
+    counter.latency "crawler.download", 2.02
+  end
+
+  it "should record a block's latency" do
+    redis.should_receive(:hincrby).with("counters", "latencies.crawler.process.count", 1).once
+    redis.should_receive(:hincrby).once.with do |key, subkey, latency|
+      key == "counters" && subkey == "latencies.crawler.process.nanoseconds" && latency >= 0.2 * 1_000_000_000 && latency < 0.3 * 1_000_000_000
+    end
+    counter.latency "crawler.process" do
+      sleep 0.2
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require "counters"
+require "timecop"
+
+shared_examples_for "all counters" do
+  it "should raise a ArgumentError when the key includes invalid chars" do
+    lambda { counter.hit "hit!"        } .should raise_error(ArgumentError)
+    lambda { counter.hit "hit counter" } .should raise_error(ArgumentError)
+    lambda { counter.hit "boy.hit?"    } .should raise_error(ArgumentError)
+    lambda { counter.hit "hit/a"       } .should raise_error(ArgumentError)
+    lambda { counter.hit "hit-a"       } .should raise_error(ArgumentError)
+    lambda { counter.hit ""            } .should raise_error(ArgumentError)
+    lambda { counter.hit nil           } .should raise_error(ArgumentError)
+  end
+
+  it "should not raise ArgumentError when the key includes a number" do
+    lambda { counter.hit "hit1" }.should_not raise_error(ArgumentError)
+  end
+
+  it "should not raise ArgumentError when the key includes a dot / fullstop" do
+    lambda { counter.hit "hit." }.should_not raise_error(ArgumentError)
+  end
+
+  it "should not raise ArgumentError when the key includes an underscore" do
+    lambda { counter.hit "hit_" }.should_not raise_error(ArgumentError)
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: counters
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- "Fran\xC3\xA7ois Beausoleil"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-26 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Using the provided API, record metrics (such as number of hits to a particular controller, bytes in/out, compression ratio) within your system. Visualization is NOT provided within this gem.
+email: 
+- francois@teksol.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.textile
+- Rakefile
+- autotest/discover.rb
+- counters.gemspec
+- lib/counters.rb
+- lib/counters/base.rb
+- lib/counters/file.rb
+- lib/counters/memory.rb
+- lib/counters/redis.rb
+- lib/counters/version.rb
+- spec/file_counter_spec.rb
+- spec/memory_counter_spec.rb
+- spec/redis_counter_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides an API to record any kind of metrics within your system
+test_files: 
+- spec/file_counter_spec.rb
+- spec/memory_counter_spec.rb
+- spec/redis_counter_spec.rb
+- spec/spec_helper.rb