tabs 0.5.0

data/.gitignore

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

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 JC Grubbs
+
+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,40 @@
+# Tabs
+
+Tabs is a redis-backed metrics tracker that supports counts, sums,
+averages, and min/max stats sliceable by the minute, hour, day, week,
+month, and year.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tabs'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tabs
+
+## Usage
+
+To count events, simply call the `increment` or `record` methods to
+write an event to the store.
+
+### Increment a counter
+
+Tabs.increment(key)
+
+### Record a value
+
+Tabs.record(key, 37)
+
+## 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 @@
+require "bundler/gem_tasks"

data/lib/tabs/config.rb

@@ -0,0 +1,18 @@
+module Tabs
+  module Config
+    extend self
+
+    def redis=(arg)
+      if arg.is_a?(Redis)
+        @redis = arg
+      else
+        @redis = Redis.new(arg)
+      end
+    end
+
+    def redis
+      @redis ||= Redis.new
+    end
+
+  end
+end

data/lib/tabs/helpers.rb

@@ -0,0 +1,34 @@
+module Tabs
+  module Helpers
+    extend self
+
+    def timestamp_range(period, resolution, default_value=0)
+      period = normalize_period(period, resolution)
+      dt = period.first
+      Hash[([].tap do |arr|
+        arr << dt
+        while (dt = dt + 1.send(resolution)) <= period.last
+          arr << dt.utc
+        end
+      end).map { |ts| [ts, default_value] }]
+    end
+
+    def normalize_period(period, resolution)
+      period_start = Tabs::Resolution.normalize(resolution, period.first)
+      period_end = Tabs::Resolution.normalize(resolution, period.last)
+      (period_start..period_end)
+    end
+
+    def extract_date_from_key(stat_key, resolution)
+      date_str = stat_key.split(":").last
+      Tabs::Resolution.deserialize(resolution, date_str)
+    end
+
+    def fill_missing_dates(period, date_value_pairs, resolution, default_value=0)
+      all_timestamps = timestamp_range(period, resolution, default_value)
+      merged = all_timestamps.merge(Hash[date_value_pairs])
+      merged.to_a
+    end
+
+  end
+end

data/lib/tabs/metrics/counter.rb

@@ -0,0 +1,43 @@
+module Tabs
+  module Metrics
+    class Counter
+      include Tabs::Storage
+      include Tabs::Helpers
+
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+      end
+
+      def increment
+        timestamp = Time.now.utc
+        Tabs::RESOLUTIONS.each do |resolution|
+          increment_resolution(resolution, timestamp)
+        end
+        true
+      end
+
+      def stats(period, resolution)
+        period = normalize_period(period, resolution)
+        keys = smembers("stat:keys:#{key}:#{resolution}")
+        dates = keys.map { |k| extract_date_from_key(k, resolution) }
+        values = mget(*keys).map(&:to_i)
+        pairs = dates.zip(values)
+        filtered_pairs = pairs.find_all { |p| period.cover?(p[0]) }
+        filtered_pairs = fill_missing_dates(period, filtered_pairs, resolution)
+        filtered_pairs.map { |p| Hash[[p]] }
+      end
+
+      private
+
+      def increment_resolution(resolution, timestamp)
+        formatted_time = Tabs::Resolution.serialize(resolution, timestamp)
+        stat_key = "stat:value:#{key}:count:#{formatted_time}"
+        sadd("stat:keys:#{key}:#{resolution}", stat_key)
+        incr(stat_key)
+      end
+
+    end
+  end
+end

data/lib/tabs/metrics/value.rb

@@ -0,0 +1,75 @@
+module Tabs
+  module Metrics
+    class Value
+      include Tabs::Storage
+      include Tabs::Helpers
+
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+      end
+
+      def record(value)
+        timestamp = Time.now.utc
+        Tabs::RESOLUTIONS.each do |resolution|
+          formatted_time = Tabs::Resolution.serialize(resolution, timestamp)
+          stat_key = "stat:value:#{key}:#{formatted_time}"
+          sadd("stat:keys:#{key}:#{resolution}", stat_key)
+          update_values(stat_key, value)
+        end
+        true
+      end
+
+      def stats(period, resolution)
+        period = normalize_period(period, resolution)
+        keys = smembers("stat:keys:#{key}:#{resolution}")
+        dates = keys.map { |k| extract_date_from_key(k, resolution) }
+        values = mget(*keys).map { |v| JSON.parse(v) }
+        pairs = dates.zip(values)
+        filtered_pairs = pairs.find_all { |p| period.cover?(p[0]) }
+        filtered_pairs = fill_missing_dates(period, filtered_pairs, resolution, default_value(0))
+        filtered_pairs.map { |p| Hash[[p]] }
+      end
+
+      private
+
+      def update_values(stat_key, value)
+        hash = get_current_hash(stat_key)
+        increment(hash, value)
+        update_min(hash, value)
+        update_max(hash, value)
+        update_avg(hash)
+        set(stat_key, JSON.generate(hash))
+      end
+
+      def get_current_hash(stat_key)
+        hash = get(stat_key)
+        return JSON.parse(hash) if hash
+        default_value
+      end
+
+      def increment(hash, value)
+        hash["count"] += 1
+        hash["sum"] += value
+      end
+
+      def update_min(hash, value)
+        hash["min"] = value if hash["min"].nil? || value < hash["min"]
+      end
+
+      def update_max(hash, value)
+        hash["max"] = value if hash["max"].nil? || value > hash["max"]
+      end
+
+      def update_avg(hash)
+        hash["avg"] = hash["sum"] / hash["count"]
+      end
+
+      def default_value(nil_value=nil)
+        { "count" => 0, "min" => nil_value, "max" => nil_value, "sum" => 0, "avg" => 0 }
+      end
+
+    end
+  end
+end

data/lib/tabs/resolution.rb

@@ -0,0 +1,24 @@
+module Tabs
+  module Resolution
+    extend self
+
+    def serialize(resolution, timestamp)
+      resolution_klass(resolution).serialize(timestamp)
+    end
+
+    def deserialize(resolution, str)
+      resolution_klass(resolution).deserialize(str)
+    end
+
+    def normalize(resolution, timestamp)
+      resolution_klass(resolution).normalize(timestamp)
+    end
+
+    private
+
+    def resolution_klass(resolution)
+      "Tabs::Resolutions::#{resolution.to_s.classify}".constantize
+    end
+
+  end
+end

data/lib/tabs/resolutions/day.rb

@@ -0,0 +1,23 @@
+module Tabs
+  module Resolutions
+    module Day
+      extend self
+
+      PATTERN = "%Y-%m-%d"
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month, ts.day)
+      end
+
+    end
+  end
+end

data/lib/tabs/resolutions/hour.rb

@@ -0,0 +1,23 @@
+module Tabs
+  module Resolutions
+    module Hour
+      extend self
+
+      PATTERN = "%Y-%m-%d-%H"
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month, ts.day, ts.hour)
+      end
+
+    end
+  end
+end

data/lib/tabs/resolutions/minute.rb

@@ -0,0 +1,23 @@
+module Tabs
+  module Resolutions
+    module Minute
+      extend self
+
+      PATTERN = "%Y-%m-%d-%H-%M"
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month, ts.day, ts.hour, ts.min)
+      end
+
+    end
+  end
+end

data/lib/tabs/resolutions/month.rb

@@ -0,0 +1,23 @@
+module Tabs
+  module Resolutions
+    module Month
+      extend self
+
+      PATTERN = "%Y-%m"
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month)
+      end
+
+    end
+  end
+end

data/lib/tabs/resolutions/week.rb

@@ -0,0 +1,25 @@
+module Tabs
+  module Resolutions
+    module Week
+      extend self
+
+      PATTERN = "%Y-%W"
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        year, week = str.split("-").map(&:to_i)
+        week = 1 if week == 0
+        dt = DateTime.strptime("#{year}-#{week}", PATTERN)
+        self.normalize(dt)
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month, ts.day).beginning_of_week
+      end
+
+    end
+  end
+end

data/lib/tabs/resolutions/year.rb

@@ -0,0 +1,23 @@
+module Tabs
+  module Resolutions
+    module Year
+      extend self
+
+      PATTERN = "%Y"
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year)
+      end
+
+    end
+  end
+end

data/lib/tabs/storage.rb

@@ -0,0 +1,59 @@
+module Tabs
+  module Storage
+    extend self
+
+    def redis
+      @redis ||= Config.redis
+    end
+
+    def exists(key)
+      redis.get("tabs:#{key}")
+    end
+
+    def get(key)
+      redis.get("tabs:#{key}")
+    end
+
+    def mget(*keys)
+      prefixed_keys = keys.map { |k| "tabs:#{k}" }
+      redis.mget(*prefixed_keys)
+    end
+
+    def set(key, value)
+      redis.set("tabs:#{key}", value)
+    end
+
+    def incr(key)
+      redis.incr("tabs:#{key}")
+    end
+
+    def rpush(key, value)
+      redis.rpush("tabs:#{key}", value)
+    end
+
+    def sadd(key, *values)
+      redis.sadd("tabs:#{key}", *values)
+    end
+
+    def smembers(key)
+      redis.smembers("tabs:#{key}")
+    end
+
+    def hget(key, field)
+      redis.hget("tabs:#{key}", field)
+    end
+
+    def hset(key, field, value)
+      redis.hset("tabs:#{key}", field, value)
+    end
+
+    def hdel(key, field)
+      redis.hdel("tabs:#{key}", field)
+    end
+
+    def hkeys(key)
+      redis.hkeys("tabs:#{key}")
+    end
+
+  end
+end

data/lib/tabs/tabs.rb

@@ -0,0 +1,70 @@
+module Tabs
+  extend self
+  extend Tabs::Storage
+
+  class UnknownTypeError < Exception; end
+  class DuplicateMetricError < Exception; end
+  class UnknownMetricError < Exception; end
+  class MetricTypeMismatchError < Exception; end
+
+  METRIC_TYPES = ["counter", "value"]
+
+  RESOLUTIONS = [:minute, :hour, :day, :week, :month, :year]
+
+  def configure
+    yield(Config)
+  end
+
+  def redis
+    Config.redis
+  end
+
+  def increment_counter(key)
+    raise UnknownMetricError.new("Unknown metric: #{key}") unless metric_exists?(key)
+    raise MetricTypeMismatchError.new("Only counter metrics can be incremented") unless metric_type(key) == "counter"
+    get_metric(key).increment
+  end
+
+  def record_value(key, value)
+    raise UnknownMetricError.new("Unknown metric: #{key}") unless metric_exists?(key)
+    raise MetricTypeMismatchError.new("Only value metrics can record a value") unless metric_type(key) == "value"
+    get_metric(key).record(value)
+  end
+
+  def create_metric(key, type)
+    raise UnknownTypeError.new("Unknown metric type: #{type}") unless METRIC_TYPES.include?(type)
+    raise DuplicateMetricError.new("Metric already exists: #{key}") if metric_exists?(key)
+    hset "metrics", key, type
+    metric_klass(type).new(key)
+  end
+
+  def get_metric(key)
+    metrics = get("metrics")
+    type = metrics[key]
+    metric_klass(type).new(key)
+  end
+
+  def metric_type(key)
+    hget "metrics", key
+  end
+
+  def drop_metric(key)
+    hdel "metrics", key
+    # TODO: Need to finish this
+  end
+
+  def list_metrics
+    hkeys "metrics"
+  end
+
+  def metric_exists?(key)
+    list_metrics.include? key
+  end
+
+  private
+
+  def metric_klass(type)
+    "Tabs::Metrics::#{type.classify}".constantize
+  end
+
+end

data/lib/tabs/version.rb

@@ -0,0 +1,3 @@
+module Tabs
+  VERSION = "0.5.0"
+end

data/lib/tabs.rb

@@ -0,0 +1,21 @@
+require "active_support/all"
+require "redis"
+require "json/ext"
+
+require "tabs/version"
+require "tabs/config"
+require "tabs/storage"
+require "tabs/helpers"
+
+require "tabs/resolution"
+require "tabs/resolutions/minute"
+require "tabs/resolutions/hour"
+require "tabs/resolutions/day"
+require "tabs/resolutions/week"
+require "tabs/resolutions/month"
+require "tabs/resolutions/year"
+
+require "tabs/metrics/counter"
+require "tabs/metrics/value"
+
+require "tabs/tabs"

data/spec/lib/tabs/metrics/counter_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+
+describe Tabs::Metrics::Counter do
+
+  let(:metric) { Tabs.create_metric("foo", "counter") }
+  let(:now) { Time.utc(2000, 1, 1, 0, 0) }
+
+  describe "incrementing stats" do
+
+    it "increments the value for the expected periods" do
+      Timecop.freeze(now)
+      metric.increment
+      time = Time.utc(now.year, now.month, now.day, now.hour)
+      stats = metric.stats(((now - 2.hours)..(now + 4.hours)), :hour)
+      expect(stats).to include({ time => 1 })
+    end
+  end
+
+  describe "retrieving stats" do
+
+    before do
+      Timecop.freeze(now)
+    end
+
+    after do
+      Timecop.return
+    end
+
+    def create_span(time_unit)
+      metric.increment
+      Timecop.freeze(now + 3.send(time_unit))
+      metric.increment
+      Timecop.freeze(now + 6.send(time_unit))
+      metric.increment
+      metric.increment
+      Timecop.freeze(now)
+    end
+
+    it "returns the expected results for an minutely metric" do
+      create_span(:minute)
+      stats = metric.stats(now..(now + 7.minutes), :minute)
+      expect(stats).to include({ (now + 3.minutes) => 1 })
+      expect(stats).to include({ (now + 6.minutes) => 2 })
+    end
+
+    it "returns the expected results for an hourly metric" do
+      create_span(:hours)
+      stats = metric.stats(now..(now + 7.hours), :hour)
+      expect(stats).to include({ (now + 3.hours) => 1 })
+      expect(stats).to include({ (now + 6.hours) => 2 })
+    end
+
+    it "returns the expected results for a daily metric" do
+      create_span(:days)
+      stats = metric.stats(now..(now + 7.days), :day)
+      expect(stats).to include({ (now + 3.days) => 1 })
+      expect(stats).to include({ (now + 6.days) => 2 })
+    end
+
+    it "returns the expected results for a monthly metric" do
+      create_span(:months)
+      stats = metric.stats(now..(now + 7.months), :month)
+      expect(stats).to include({ (now + 3.months) => 1 })
+      expect(stats).to include({ (now + 6.months) => 2 })
+    end
+
+    it "returns the expected results for a yearly metric" do
+      create_span(:years)
+      stats = metric.stats(now..(now + 7.years), :year)
+      expect(stats).to include({ (now + 3.years) => 1 })
+      expect(stats).to include({ (now + 6.years) => 2 })
+    end
+
+    it "returns zeros for time periods which do not have any events" do
+      create_span(:days)
+      stats = metric.stats(now..(now + 7.days), :day)
+      expect(stats).to include({ (now + 1.day) => 0 })
+    end
+
+    context "for weekly metrics" do
+
+      let(:period) do
+        (now - 2.days)..((now + 7.weeks) + 2.days)
+      end
+
+      it "returns the expected results for a weekly metric" do
+        create_span(:weeks)
+        stats = metric.stats(period, :week)
+        expect(stats).to include({ (now + 3.weeks).beginning_of_week => 1 })
+        expect(stats).to include({ (now + 6.weeks).beginning_of_week => 2 })
+      end
+
+      it "normalizes the period to the first day of the week" do
+        create_span(:weeks)
+        stats = metric.stats(period, :week)
+        expect(stats.first.keys[0]).to eq(period.first.beginning_of_week)
+        expect(stats.last.keys[0]).to eq(period.last.beginning_of_week)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/tabs/metrics/value_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+describe Tabs::Metrics::Value do
+
+  let(:metric) { Tabs.create_metric("foo", "value") }
+  let(:now) { Time.utc(2000, 1, 1, 0, 0) }
+
+  describe ".record" do
+
+    it "sets the expected values for the period" do
+      Timecop.freeze(now)
+      metric.record(17)
+      metric.record(42)
+      time = Time.utc(now.year, now.month, now.day, now.hour)
+      stats = metric.stats(((now - 2.hours)..(now + 4.hours)), :hour)
+      expect(stats).to include({ time => {"count"=>2, "min"=>17, "max"=>42, "sum"=>59, "avg"=>29} })
+    end
+
+  end
+
+  describe ".stats" do
+
+    before do
+      Timecop.freeze(now)
+    end
+
+    after do
+      Timecop.return
+    end
+
+    def create_span(time_unit)
+      metric.record(5)
+      Timecop.freeze(now + 3.send(time_unit))
+      metric.record(10)
+      Timecop.freeze(now + 6.send(time_unit))
+      metric.record(15)
+      metric.record(20)
+      Timecop.freeze(now)
+    end
+
+    it "returns the expected results for an minutely metric" do
+      create_span(:minutes)
+      stats = metric.stats(now..(now + 7.minutes), :minute)
+      expect(stats).to include({ (now + 3.minutes) => {"count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10} })
+      expect(stats).to include({ (now + 6.minutes) => {"count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17} })
+    end
+
+    it "returns the expected results for an hourly metric" do
+      create_span(:hours)
+      stats = metric.stats(now..(now + 7.hours), :hour)
+      expect(stats).to include({ (now + 3.hours) => {"count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10} })
+      expect(stats).to include({ (now + 6.hours) => {"count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17} })
+    end
+
+    it "returns the expected results for a daily metric" do
+      create_span(:days)
+      stats = metric.stats(now..(now + 7.days), :day)
+      expect(stats).to include({ (now + 3.days) => {"count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10} })
+      expect(stats).to include({ (now + 6.days) => {"count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17} })
+    end
+
+    it "returns the expected results for a weekly metric" do
+      create_span(:weeks)
+      stats = metric.stats(now..(now + 7.weeks), :week)
+      expect(stats).to include({ (now + 3.weeks).beginning_of_week => {"count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10} })
+      expect(stats).to include({ (now + 6.weeks).beginning_of_week => {"count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17} })
+    end
+
+    it "returns the expected results for a monthly metric" do
+      create_span(:months)
+      stats = metric.stats(now..(now + 7.months), :month)
+      expect(stats).to include({ (now + 3.months) => {"count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10} })
+      expect(stats).to include({ (now + 6.months) => {"count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17} })
+    end
+
+    it "returns the expected results for a yearly metric" do
+      create_span(:years)
+      stats = metric.stats(now..(now + 7.years), :year)
+      expect(stats).to include({ (now + 3.years) => {"count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10} })
+      expect(stats).to include({ (now + 6.years) => {"count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17} })
+    end
+
+  end
+
+end

data/spec/lib/tabs_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+
+describe Tabs do
+
+  describe "#create_metric" do
+
+    it "raises an error if the type is invalid" do
+      lambda { Tabs.create_metric("foo", "foobar") }.should raise_error(Tabs::UnknownTypeError)
+    end
+
+    it "raises an error if the metric already exists" do
+      Tabs.create_metric("foo", "counter")
+      lambda { Tabs.create_metric("foo", "counter") }.should raise_error(Tabs::DuplicateMetricError)
+    end
+
+    it "returns a Counter metric if 'counter' was the specified type" do
+      expect(Tabs.create_metric("foo", "counter")).to be_a_kind_of(Tabs::Metrics::Counter)
+    end
+
+    it "returns a Value metric if 'value' was the specified type" do
+      expect(Tabs.create_metric("foo", "value")).to be_a_kind_of(Tabs::Metrics::Value)
+    end
+
+    it "adds the metric's key to the list_metrics" do
+      Tabs.create_metric("foo", "value")
+      Tabs.create_metric("bar", "counter")
+      expect(Tabs.list_metrics).to include("foo")
+      expect(Tabs.list_metrics).to include("bar")
+    end
+
+  end
+
+  describe "#get_metric" do
+
+    it "returns the expected metric object" do
+      Tabs.create_metric("foo", "counter")
+      expect(Tabs.get_metric("foo")).to be_a_kind_of(Tabs::Metrics::Counter)
+    end
+
+  end
+
+  describe "#list_metrics" do
+
+    it "returns the list_metrics of metric names" do
+      Tabs.create_metric("foo", "counter")
+      Tabs.create_metric("bar", "value")
+      expect(Tabs.list_metrics).to eq(["foo", "bar"])
+    end
+
+  end
+
+  describe "#metric_exists?" do
+
+    it "returns true if the metric exists" do
+      Tabs.create_metric("foo", "counter")
+      expect(Tabs.metric_exists?("foo")).to be_true
+    end
+
+    it "returns false if the metric does not exist" do
+      expect(Tabs.metric_exists?("foo")).to be_false
+    end
+
+  end
+
+  describe "#drop_metric" do
+
+    before do
+      Tabs.create_metric("foo", "counter")
+    end
+
+    it "removes the metric from the list_metrics" do
+      Tabs.drop_metric("foo")
+      expect(Tabs.list_metrics).to_not include("foo")
+      expect(Tabs.metric_exists?("foo")).to be_false
+    end
+
+    it "removes the metrics values from redis"
+
+  end
+
+  describe "#increment_counter" do
+
+    it "raises an Tabs::UnknownMetricError if the metric does not exist" do
+      lambda { Tabs.increment_counter("foo") }.should raise_error(Tabs::UnknownMetricError)
+    end
+
+    it "raises a Tabs::MetricTypeMismatchError if the metric is the wrong type" do
+      Tabs.create_metric("foo", "value")
+      lambda { Tabs.increment_counter("foo") }.should raise_error(Tabs::MetricTypeMismatchError)
+    end
+
+    it "calls increment on the metric" do
+      metric = Tabs.create_metric("foo", "counter")
+      Tabs.stub(get_metric: metric)
+      metric.should_receive(:increment)
+      Tabs.increment_counter("foo")
+    end
+
+  end
+
+  describe "#increment_counter" do
+
+    it "raises an Tabs::UnknownMetricError if the metric does not exist" do
+      lambda { Tabs.record_value("foo", 27) }.should raise_error(Tabs::UnknownMetricError)
+    end
+
+    it "raises a Tabs::MetricTypeMismatchError if the metric is the wrong type" do
+      Tabs.create_metric("foo", "counter")
+      lambda { Tabs.record_value("foo", 27) }.should raise_error(Tabs::MetricTypeMismatchError)
+    end
+
+    it "calls record on the metric" do
+      metric = Tabs.create_metric("foo", "value")
+      Tabs.stub(get_metric: metric)
+      metric.should_receive(:record).with(42)
+      Tabs.record_value("foo", 42)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require "rubygems"
+require "tabs"
+require "fakeredis/rspec"
+require "pry"
+require "timecop"
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/tabs.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tabs/version'
+
+Gem::Specification.new do |gem|
+
+  gem.name          = "tabs"
+  gem.version       = Tabs::VERSION
+  gem.authors       = ["JC Grubbs"]
+  gem.email         = ["jc.grubbs@devmynd.com"]
+  gem.description   = %q{A redis-backed metrics tracker for keeping tabs on pretty much anything ;)}
+  gem.summary       = %q{A redis-backed metrics tracker for keeping tabs on pretty much anything ;)}
+  gem.homepage      = "https://github.com/thegrubbsian/tabs"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "redis", "~> 3.0.2"
+  gem.add_dependency "activesupport", "~> 3.2.11"
+  gem.add_dependency "json", "~> 1.7.7"
+
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "fakeredis"
+  gem.add_development_dependency "timecop"
+
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: tabs
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- JC Grubbs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A redis-backed metrics tracker for keeping tabs on pretty much anything
+  ;)
+email:
+- jc.grubbs@devmynd.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tabs.rb
+- lib/tabs/config.rb
+- lib/tabs/helpers.rb
+- lib/tabs/metrics/counter.rb
+- lib/tabs/metrics/value.rb
+- lib/tabs/resolution.rb
+- lib/tabs/resolutions/day.rb
+- lib/tabs/resolutions/hour.rb
+- lib/tabs/resolutions/minute.rb
+- lib/tabs/resolutions/month.rb
+- lib/tabs/resolutions/week.rb
+- lib/tabs/resolutions/year.rb
+- lib/tabs/storage.rb
+- lib/tabs/tabs.rb
+- lib/tabs/version.rb
+- spec/lib/tabs/metrics/counter_spec.rb
+- spec/lib/tabs/metrics/value_spec.rb
+- spec/lib/tabs_spec.rb
+- spec/spec_helper.rb
+- tabs.gemspec
+homepage: https://github.com/thegrubbsian/tabs
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A redis-backed metrics tracker for keeping tabs on pretty much anything ;)
+test_files:
+- spec/lib/tabs/metrics/counter_spec.rb
+- spec/lib/tabs/metrics/value_spec.rb
+- spec/lib/tabs_spec.rb
+- spec/spec_helper.rb