abaci 0.1.0 → 0.2.0

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## Abaci 0.2.0
+
+* Added testing suite
+* Storing of all stat metrics
+* Stat summary with `Abaci.summary`
+* If the `Stat` class is not defined, use it as a shortcut for `Abaci::Counter`
+
 ## Abaci 0.1.0
 
 * Initial build

data/lib/abaci.rb

@@ -2,6 +2,8 @@ require 'abaci/version'
 
 module Abaci
   autoload :Counter,      'abaci/counter'
+  autoload :DateRange,    'abaci/date_range'
+  autoload :Metric,       'abaci/metric'
   autoload :Store,        'abaci/store'
 
   # Configuration options
@@ -10,6 +12,11 @@ module Abaci
       Counter[key]
     end
 
+    # Gets all specific metrics stored, without date-specific keys
+    def metrics
+      Metric.all
+    end
+
     def options
       @options ||= {
         :redis => nil,
@@ -17,12 +24,36 @@ module Abaci
       }
     end
 
+    def prefix=(value)
+      @store = nil
+      options[:prefix] = value
+    end
+
     def prefix
       options[:prefix]
     end
 
+    def redis=(value)
+      @store = nil
+      options[:redis] = value
+    end
+
     def store
       @store ||= Store.new(options)
     end
+    alias_method :redis, :store
+
+    def summary
+      Counter.all
+    end
+
+    def method_missing(method, *args)
+      Counter.send(method, *args)
+    end
+  end
+
+  # Alias Stat to Abaci::Counter if nothing else is using the Stat namespace
+  unless defined?(::Stat)
+    ::Stat = Counter
   end
 end

data/lib/abaci/counter.rb

@@ -18,6 +18,7 @@ module Abaci
 
     def del
       keys.each { |k| Abaci.store.del(k) }
+      Metric.remove(key)
       true
     end
 
@@ -27,9 +28,7 @@ module Abaci
     end
 
     def get_last_days(number_of_days = 30)
-      seconds = number_of_days.to_i * 86400
-      start = (Date.today - Rational(seconds, 86400)).to_date
-      dates = (start..Date.today).map { |d| d.strftime('%Y:%-m:%-d') }
+      dates = DateRange.ago(number_of_days).keys
       dates.map { |date| Abaci.store.get("#{key}:#{date}" ).to_i }.reduce(:+)
     end
 
@@ -40,6 +39,7 @@ module Abaci
 
     def increment_at(date = nil, by = 1)
       date = Time.now unless date.respond_to?(:strftime)
+      Metric.add(key)
       run(:incrby, by, date)
     end
 
@@ -50,9 +50,14 @@ module Abaci
     ## Class methods ##
     ############################################################################
 
+    # Alias for Counter#new(key)
+    def self.[](key)
+      Counter.new(key)
+    end
+
     # Returns a hash of all current values
     def self.all
-      keys.inject({}) { |hash, key| hash[key] = Abaci.store.get(key).to_i; hash }
+      Metric.all.inject({}) { |hash, key| hash[key.to_sym] = Abaci.store.get(key).to_i; hash }
     end
 
     # Gets all currently logged stat keys
@@ -60,11 +65,6 @@ module Abaci
       Abaci.store.keys(search).sort
     end
 
-    # Alias for Counter#new(key)
-    def self.[](key)
-      Counter.new(key)
-    end
-
     def self.method_missing(method, *args)
       ms = method.to_s.downcase.strip
 
@@ -74,11 +74,9 @@ module Abaci
         return self[$2].del
       elsif ms =~ /^last_(\d*)_days_of_([a-z_]*)$/
         return self[$2].get_last_days($1)
-      elsif ms =~ /[a-z_]*/
-        return self[ms].get(*args)
+      else
+        self[ms].get(*args)
       end
-
-      super
     end
 
     ## Protected methods ##

data/lib/abaci/date_range.rb

@@ -0,0 +1,41 @@
+module Abaci
+  class DateRange
+    attr_reader :start, :finish
+
+    def initialize(start, finish)
+      if start < finish
+        @start = start
+        @finish = finish
+      else
+        @start = finish
+        @finish = start
+      end
+    end
+
+    def days
+      range.to_a
+    end
+
+    def keys
+      days.map { |d| d.strftime('%Y:%-m:%-d') }
+    end
+
+    def range
+      start..finish
+    end
+
+    def self.ago(days = 30)
+      seconds = days.to_i * 86400
+      start = (Date.today - Rational(seconds, 86400)).to_date
+      new(start, Date.today)
+    end
+
+    def self.between(start, finish)
+      new(start, finish)
+    end
+
+    def self.since(date)
+      new(date, Date.today)
+    end
+  end
+end

data/lib/abaci/metric.rb

@@ -0,0 +1,15 @@
+module Abaci
+  class Metric
+    def self.add(key)
+      Abaci.store.sadd('_metrics', key)
+    end
+
+    def self.all
+      Abaci.store.smembers('_metrics')
+    end
+
+    def self.remove(key)
+      Abaci.store.srem('_metrics', key)
+    end
+  end
+end

data/lib/abaci/store.rb

@@ -4,6 +4,8 @@ module Abaci
   # Common interface for Redis. In the future this could be
   # swapped out for an alternate datastore.
   class Store
+    attr_reader :prefix, :redis
+
     def initialize(options)
       @redis = options[:redis] || Redis.current
       @prefix = options[:prefix] || 'ab'
@@ -25,8 +27,8 @@ module Abaci
       exec(:incrby, key, by)
     end
 
-    def keys(pattern)
-      sub = Regexp.new("^#{Abaci.prefix}:")
+    def keys(pattern = "*")
+      sub = Regexp.new("^#{prefix}:")
       exec(:keys, pattern).map { |k| k.gsub(sub, '') }
     end
 
@@ -34,6 +36,18 @@ module Abaci
       exec(:set, key, value)
     end
 
+    def sadd(key, member)
+      exec_without_prefix(:sadd, "#{prefix}-#{key}", member)
+    end
+
+    def smembers(key)
+      exec_without_prefix(:smembers, "#{prefix}-#{key}")
+    end
+
+    def srem(key, member)
+      exec_without_prefix(:srem, "#{prefix}-#{key}", member)
+    end
+
     protected
       def exec(command, key, *args)
         if @redis and @redis.respond_to?(command)
@@ -41,8 +55,14 @@ module Abaci
         end
       end
 
+      def exec_without_prefix(command, key, *args)
+        if @redis and @redis.respond_to?(command)
+          @redis.send(command, key, *args)
+        end
+      end
+
       def prefixed_key(key)
-        [ @prefix, key ].compact.join(':')
+        [ prefix, key ].compact.join(':')
       end
   end
 end

data/lib/abaci/version.rb

@@ -1,3 +1,3 @@
 module Abaci
-  VERSION = "0.1.0" unless defined?(::Abaci::VERSION)
+  VERSION = "0.2.0" unless defined?(::Abaci::VERSION)
 end

data/test/counter_test.rb

@@ -0,0 +1,199 @@
+require 'helper'
+
+class CounterTest < Test::Unit::TestCase
+  context "A counter" do
+    should "increment a stat" do
+      assert_equal 0, Abaci['testers'].get
+
+      Abaci['testers'].increment
+
+      assert_equal 1, Abaci['testers'].get
+
+      Abaci['testers'].increment(2)
+
+      assert_equal 3, Abaci['testers'].get
+    end
+
+    should "decrement a stat" do
+      assert_equal 0, Abaci['testers'].get
+
+      Abaci['testers'].increment(5)
+      assert_equal 5, Abaci['testers'].get
+
+      Abaci['testers'].decrement
+      assert_equal 4, Abaci['testers'].get
+
+      Abaci['testers'].decrement(2)
+      assert_equal 2, Abaci['testers'].get
+    end
+
+    should "increment a stat down to the minute" do
+      now = Time.now
+
+      Abaci['people'].increment
+
+      expected_keys = [
+        'people',
+        "people:#{now.strftime('%Y')}",
+        "people:#{now.strftime('%Y:%-m')}",
+        "people:#{now.strftime('%Y:%-m:%-d')}",
+        "people:#{now.strftime('%Y:%-m:%-d:%-k')}",
+        "people:#{now.strftime('%Y:%-m:%-d:%-k:%-M')}"
+      ].sort
+
+      assert_equal expected_keys, Abaci['people'].keys.sort
+
+      assert_equal 1, Abaci['people'].get
+      assert_equal 1, Abaci['people'].get(now.year)
+      assert_equal 1, Abaci['people'].get(now.year, now.month)
+      assert_equal 1, Abaci['people'].get(now.year, now.month, now.day)
+      assert_equal 1, Abaci['people'].get(now.year, now.month, now.day, now.hour)
+      assert_equal 1, Abaci['people'].get(now.year, now.month, now.day, now.hour, now.min)
+    end
+
+    should "increment a stat at a certain date" do
+      time = Time.new(2012, 2, 29, 23, 29)
+
+      Abaci['people'].increment_at(time)
+
+      expected_keys = [
+        'people',
+        "people:2012",
+        "people:2012:2",
+        "people:2012:2:29",
+        "people:2012:2:29:23",
+        "people:2012:2:29:23:29"
+      ].sort
+
+      assert_equal expected_keys, Abaci['people'].keys.sort
+
+      assert_equal 1, Abaci['people'].get
+      assert_equal 1, Abaci['people'].get(2012)
+      assert_equal 1, Abaci['people'].get(2012, 2)
+      assert_equal 1, Abaci['people'].get(2012, 2, 29)
+      assert_equal 1, Abaci['people'].get(2012, 2, 29, 23)
+      assert_equal 1, Abaci['people'].get(2012, 2, 29, 23, 29)
+    end
+
+    should "get stats summary for last 5 days" do
+      time = Time.new(2012, 5, 30, 5, 0)
+      time2 = Time.new(2012, 5, 31, 5, 0)
+      time3 = Time.new(2012, 6, 1, 5, 0)
+      time4 = Time.new(2012, 6, 2, 5, 0)
+
+      Abaci['people'].increment_at(time)
+      Abaci['people'].increment_at(time2)
+      Abaci['people'].increment_at(time3)
+      Abaci['people'].increment_at(time4)
+      Abaci['people'].increment
+
+      Date.stubs(:today).returns(Date.new(2012, 6, 2))
+
+      assert_equal 5, Abaci['people'].get
+      assert_equal 4, Abaci['people'].get_last_days(30)
+      assert_equal 3, Abaci['people'].get_last_days(2)
+      assert_equal 2, Abaci['people'].get_last_days(1)
+
+      Date.unstub(:today)
+    end
+
+    should "delete stats for a given key" do
+      time = Time.new(2012, 2, 29, 23, 29)
+
+      Abaci['people'].increment_at(time)
+
+      expected_keys = [
+        'people',
+        "people:2012",
+        "people:2012:2",
+        "people:2012:2:29",
+        "people:2012:2:29:23",
+        "people:2012:2:29:23:29"
+      ].sort
+
+      assert_equal expected_keys, Abaci['people'].keys.sort
+
+      Abaci['people'].del
+
+      assert_equal [], Abaci['people'].keys
+    end
+
+    should "return all stat keys across all metrics" do
+      time = Time.new(2012, 2, 29, 23, 29)
+
+      Abaci['people'].increment_at(time)
+      Abaci['places'].increment_at(time)
+      Abaci['things'].increment_at(time)
+
+      expected_keys = [
+        'people',
+        "people:2012",
+        "people:2012:2",
+        "people:2012:2:29",
+        "people:2012:2:29:23",
+        "people:2012:2:29:23:29",
+        'places',
+        "places:2012",
+        "places:2012:2",
+        "places:2012:2:29",
+        "places:2012:2:29:23",
+        "places:2012:2:29:23:29",
+        'things',
+        "things:2012",
+        "things:2012:2",
+        "things:2012:2:29",
+        "things:2012:2:29:23",
+        "things:2012:2:29:23:29"
+      ].sort
+
+      assert_equal expected_keys, Abaci.keys.sort
+    end
+
+    should "return all metrics stores, without date-specific keys" do
+      time = Time.new(2012, 2, 29, 23, 29)
+
+      Abaci['people'].increment_at(time)
+      Abaci['places'].increment_at(time)
+      Abaci['things'].increment_at(time)
+
+      expected_keys = %w( people places things ).sort
+
+      assert_equal expected_keys, Abaci.metrics.sort
+    end
+
+    should "return a hash of all top-level metrics and current values" do
+      Abaci['people'].increment
+      Abaci['places'].increment
+      Abaci['things'].increment(2)
+
+      expected_result = {
+        :people => 1,
+        :places => 1,
+        :things => 2
+      }
+
+      assert_equal expected_result, Abaci.summary
+    end
+
+    should "have handy shortcuts for incrementing simple metrics" do
+      Abaci.increment_people
+      Abaci.increment_places(2)
+      Abaci.increase_things
+      Abaci.incr_people
+
+      assert_equal 2, Abaci.people
+      assert_equal 2, Abaci.places
+      assert_equal 1, Abaci.things
+
+      Abaci.decrease_things
+
+      assert_equal 0, Abaci.things
+
+      Abaci.clear_people!
+
+      assert_equal 0, Abaci.people
+
+      assert_equal 2, Abaci.last_20_days_of_places
+    end
+  end
+end

data/test/date_range_test.rb

@@ -0,0 +1,95 @@
+require 'helper'
+
+class DateRangeTest < Test::Unit::TestCase
+  context "The date range calculator" do
+    should "get a day X days in the past" do
+      time = Date.new(2012, 11, 6)
+      expected_time = Date.new(2012, 11, 1)
+
+      Date.stubs(:today).returns(time)
+
+      assert_equal expected_time, Abaci::DateRange.ago(5).start
+
+      Date.unstub(:today)
+    end
+
+    should "get days since a given date" do
+      time = Date.new(2012, 11, 6)
+      expected_time = Date.new(2012, 11, 1)
+
+      Date.stubs(:today).returns(time)
+
+      since = Abaci::DateRange.since(expected_time)
+
+      assert_equal expected_time, since.start
+      assert_equal time, since.finish
+
+      Date.unstub(:today)
+    end
+
+    should "get days between a given date range" do
+      day1 = Date.new(2012, 11, 1)
+      day2 = Date.new(2012, 11, 6)
+
+      range = Abaci::DateRange.between(day1, day2)
+
+      assert_equal day1, range.start
+      assert_equal day2, range.finish
+    end
+
+    should "make days are in order" do
+      day1 = Date.new(2012, 11, 1)
+      day2 = Date.new(2012, 11, 6)
+
+      range = Abaci::DateRange.between(day2, day1)
+
+      assert_equal day1, range.start
+      assert_equal day2, range.finish
+    end
+
+    should "have a range of days" do
+      day1 = Date.new(2012, 11, 1)
+      day2 = Date.new(2012, 11, 6)
+
+      range = Abaci::DateRange.between(day2, day1)
+
+      assert_equal (day1..day2), range.range
+    end
+
+    should "have an array of days" do
+      day1 = Date.new(2012, 11, 1)
+      day2 = Date.new(2012, 11, 6)
+
+      range = Abaci::DateRange.between(day2, day1)
+
+      expected_result = [
+        Date.new(2012, 11, 1),
+        Date.new(2012, 11, 2),
+        Date.new(2012, 11, 3),
+        Date.new(2012, 11, 4),
+        Date.new(2012, 11, 5),
+        Date.new(2012, 11, 6)
+      ]
+
+      assert_equal expected_result, range.days
+    end
+
+    should "have a list of store keys for a range" do
+      day1 = Date.new(2012, 11, 1)
+      day2 = Date.new(2012, 11, 6)
+
+      range = Abaci::DateRange.between(day2, day1)
+
+      expected_result = [
+        '2012:11:1',
+        '2012:11:2',
+        '2012:11:3',
+        '2012:11:4',
+        '2012:11:5',
+        '2012:11:6'
+      ]
+
+      assert_equal expected_result, range.keys
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,23 @@
+# SimpleCov provides test coverage in ruby 1.9 environments only, fail silently
+# if it is not available
+begin; require 'simplecov'; rescue LoadError; end
+
+require 'shoulda'
+require 'test/unit'
+require 'mocha'
+require 'redis'
+require 'abaci'
+
+# Fail silently if Turn is not available (runs in 1.9+ only)
+begin; require 'turn/autorun'; rescue LoadError; end
+
+REDIS = Redis.new(:db => 1)
+
+Abaci.redis = REDIS
+
+class Test::Unit::TestCase
+  def setup
+    REDIS.flushdb
+    Abaci.prefix = 'ab-test'
+  end
+end

data/test/store_test.rb

@@ -0,0 +1,81 @@
+require 'helper'
+
+class StoreTest < Test::Unit::TestCase
+  context "The abaci store" do
+    should "use a prefix for storage" do
+      Abaci.prefix = 'ab-test'
+      assert_equal 'ab-test', Abaci.prefix
+
+      assert_equal 0, Abaci['prefixes'].get
+
+      assert_equal nil, REDIS.get("ab-test:prefixes")
+
+      Abaci['prefixes'].increment
+      assert_equal 1, Abaci['prefixes'].get
+
+      assert_equal "1", REDIS.get("ab-test:prefixes")
+    end
+
+    should "be able to change the prefix" do
+      Abaci.prefix = 'ab-test-too'
+
+      assert_equal nil, REDIS.get("ab-test:prefixes")
+      assert_equal nil, REDIS.get("ab-test-too:prefixes")
+
+      Abaci.store.set 'prefixes', 1
+
+      assert_equal nil, REDIS.get("ab-test:prefixes")
+      assert_equal "1", REDIS.get("ab-test-too:prefixes")
+    end
+
+    should "list out all keys without prefixes" do
+      now = Time.now
+
+      Abaci['people'].increment
+
+      expected_redis_keys = [
+        'ab-test:people',
+        "ab-test:people:#{now.strftime('%Y')}",
+        "ab-test:people:#{now.strftime('%Y:%-m')}",
+        "ab-test:people:#{now.strftime('%Y:%-m:%-d')}",
+        "ab-test:people:#{now.strftime('%Y:%-m:%-d:%-k')}",
+        "ab-test:people:#{now.strftime('%Y:%-m:%-d:%-k:%-M')}"
+      ].sort
+
+      assert_equal expected_redis_keys, REDIS.keys("ab-test:*").sort
+
+      expected_abaci_keys = [
+        'people',
+        "people:#{now.strftime('%Y')}",
+        "people:#{now.strftime('%Y:%-m')}",
+        "people:#{now.strftime('%Y:%-m:%-d')}",
+        "people:#{now.strftime('%Y:%-m:%-d:%-k')}",
+        "people:#{now.strftime('%Y:%-m:%-d:%-k:%-M')}"
+      ].sort
+
+      assert_equal expected_abaci_keys, Abaci.store.keys.sort
+    end
+
+    should "be able to delete keys" do
+      Abaci['ipods'].increment
+
+      assert_equal 1, Abaci['ipods'].get
+
+      Abaci.store.del('ipods')
+
+      assert_equal 0, Abaci['ipods'].get
+    end
+
+    should "add list and remove items from a set" do
+      Abaci.store.sadd('_metrics', 'people')
+      Abaci.store.sadd('_metrics', 'places')
+      Abaci.store.sadd('_metrics', 'things')
+
+      assert_equal %w( people places things ).sort, Abaci.store.smembers('_metrics').sort
+
+      Abaci.store.srem('_metrics', 'things')
+
+      assert_equal %w( people places ).sort, Abaci.store.smembers('_metrics').sort
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: abaci
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -35,7 +35,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- test/counter_test.rb
+- test/date_range_test.rb
+- test/helper.rb
+- test/store_test.rb
 - lib/abaci/counter.rb
+- lib/abaci/date_range.rb
+- lib/abaci/metric.rb
 - lib/abaci/store.rb
 - lib/abaci/version.rb
 - lib/abaci.rb