tabs 0.5.6 → 0.6.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZGVkZDU2ZjE2NzVjMDFiNjRjZDVmZWQyODQzNmE0MzZmMWE3MzRkZA==
+  data.tar.gz: !binary |-
+    ZThhYTI3ODI5ZGNhM2M5ZmU2MWE4YTg0YzljOTQ3NDIyNDg1Njc4YQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MDJjNzY3YzM5MTAyYmJkOWUyYWMwYmNhYmU0YWY2YjcwYWJmMjQ2ZWRiZGZj
+    MDU0MjU2MzJiMTE5NzNlMDcwMzY0YmI2MTJmNzg5YzdmMmIyMjdkMjg5NjAz
+    ZDJiMjExMjNhNGI2YjY3MWJmNjg0ODJjODk3Mjc0ZjJhM2QxYjc=
+  data.tar.gz: !binary |-
+    M2U3MDczNmZhNjJhYzE5MDA2NzlkMzliYjQ0MzBmOWUxNmVmNDU0Zjc0MWRk
+    ZWNiNDVmOTEzNDdjMzQ3YWRlMzRkNGI2ZTk3MWYyNmYwYTk5MjMyYzVkNDQ3
+    OTRlZjA1ZTIzYzY0ZjQ5ZTljNjQ2MGZiYTkwMTkwYmVhNzZmMDg=

data/.travis.yml

@@ -1,5 +1,3 @@
 language: ruby
 rvm:
   - 1.9.3
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx-19mode

data/README.md

@@ -18,6 +18,14 @@ Or install it yourself as:
 
     $ gem install tabs
 
+## Breaking Changes in v0.6.0
+
+Please note that when the library version went from 0.5.6 to 0.6.0 some of
+the key patterns used to store metrics in Redis were changed.  If you upgrade
+an app to 0.6.0 the previous set of data will not be picked up by tabs.
+Please us 0.6.0 on new applications only.  However, the 'Task' metric
+type will only be available in v0.6.0 and above.
+
 ## Usage
 
 Metrics come in two flavors: counters and values.
@@ -26,34 +34,42 @@ Metrics come in two flavors: counters and values.
 
 A counter metric simply records the number of events that occur within a given timeframe.  To create a counter metric called ‘website-visits’, simply call:
 
-    Tabs.create_metric(“website-visits”, “counter”)
+```ruby
+Tabs.create_metric("website-visits", "counter")
+```
 
 Tabs will also create a counter metric automatically the first time you
 increment the counter.
 
 To increment a metric counter, simply call:
 
-    Tabs.increment_counter(“website-visits”)
+```ruby
+Tabs.increment_counter("website-visits")
+```
 
 To retrieve the counts for a given time period just call `Tabs#get_stats` with the name of the metric, a range of times defining the period for which you want stats, and the resolution at which the data should be aggregated.
 
-    Tabs.get_stats(“website-visits”, (Time.now - 10.days)..Time.now, :hour)
+```ruby
+Tabs.get_stats("website-visits", (Time.now - 10.days)..Time.now, :hour)
+```
     
 This will return stats for the last 10 days by hour as an array of hashes in which the keys are an instance of `Time` and the value is the count for that time.
 
-    [
-      { 2000-01-01 00:00:00 UTC => 1 },
-      { 2000-01-01 01:00:00 UTC => 0 },
-      { 2000-01-01 02:00:00 UTC => 10 },
-      { 2000-01-01 03:00:00 UTC => 1 },
-      { 2000-01-01 04:00:00 UTC => 0 },
-      { 2000-01-01 05:00:00 UTC => 0 },
-      { 2000-01-01 06:00:00 UTC => 3 },
-      { 2000-01-01 07:00:00 UTC => 0 },
-      ...
-    ]
+```ruby
+[
+  { 2000-01-01 00:00:00 UTC => 1 },
+  { 2000-01-01 01:00:00 UTC => 0 },
+  { 2000-01-01 02:00:00 UTC => 10 },
+  { 2000-01-01 03:00:00 UTC => 1 },
+  { 2000-01-01 04:00:00 UTC => 0 },
+  { 2000-01-01 05:00:00 UTC => 0 },
+  { 2000-01-01 06:00:00 UTC => 3 },
+  { 2000-01-01 07:00:00 UTC => 0 },
+  ...
+]
+```
     
-Times for the given period in which no events occurred will be “filled in” with a zero value to make visualizations easier.
+Times for the given period in which no events occurred will be "filled in" with a zero value to make visualizations easier.
 
 The `Time` keys are also normalized.  For example, in hour resolution, the minutes and seconds of the `Time` object are set to 00:00.  Likewise for the week resolution, the day is set to the first day of the week.
 
@@ -63,29 +79,74 @@ Value metrics take a value and record the min, max, avg, and sum for a given tim
 
 To record a value, simply call `Tabs#record_value`.
 
-    Tabs.record_value(“new-user-age”, 32)
+```ruby
+Tabs.record_value("new-user-age", 32)
+```
 
 This will also create a value metric the first time, you can manually create
 a metric as well:
 
-    Tabs.create_metric("new-user-age", "value")
+```ruby
+Tabs.create_metric("new-user-age", "value")
+```
     
 Retrieving the stats for a value metric is just like retrieving a counter metric.
 
-    Tabs.get_stats(“new-user-age”, (Time.now - 6.months)..Time.now, :month)
+```ruby
+Tabs.get_stats("new-user-age", (Time.now - 6.months)..Time.now, :month)
+```
     
 This will return a familiar value, but with an expanded set of values.
 
-    [
-      { 2000-01-01 00:00:00 UTC => { min: 19, max: 54, sum: 226, avg: 38 } },
-      { 2000-02-01 01:00:00 UTC => { min: 0, max: 0, sum: 0, avg: 0 } },
-      { 2000-03-01 02:00:00 UTC => { min: 22, max: 34, sum: 180, avg: 26 } },
-      ...
-    ]
+```ruby
+[
+  { 2000-01-01 00:00:00 UTC => { min: 19, max: 54, sum: 226, avg: 38 } },
+  { 2000-02-01 01:00:00 UTC => { min: 0, max: 0, sum: 0, avg: 0 } },
+  { 2000-03-01 02:00:00 UTC => { min: 22, max: 34, sum: 180, avg: 26 } },
+  ...
+]
+```
+
+### Task Metrics
+
+Task metrics allow you to track the beginning and ending of a process.
+For example, tracking a user who downloads you mobile application and
+later visits your website to make a purchase.
+
+```ruby
+Tabs.start_task("mobile-to-purchase", "2g4hj17787s")
+```
+
+The first argument is the metric key and the second is a unique token
+used to identify the given process.  You can use any string for the
+token but it needs to be unique.  Use the `complete_task` method to
+finish the task:
+
+```ruby
+Tabs.complete_task("mobile-to-purchase", "2g4hj17787s")
+```
+
+Retrieving stats for a task metric is just like the other types:
+
+```ruby
+Tabs.get_stats("mobile-to-purchase", (Time.now - 6.hours)..Time.now), : minute)
+```
+
+This will return a hash like this:
+
+```ruby
+{
+  started: 3,                     #=> number of items started within the period
+  completed: 2,                   #=> number of items completed within the period
+  completed_within_period: 2,     #=> number started AND completed within the period
+  completion_rate: 0.18,          #=> rate of completion
+  average_completion_time: 1.5    #=> average completion time in the specified resolution
+}
+```
 
 ### Resolutions
 
-When tabs increments a counter or records a value it does so for each of the following “resolutions”.  You may supply any of these as the last argument to the `Tabs#get_stats` method.
+When tabs increments a counter or records a value it does so for each of the following "resolutions".  You may supply any of these as the last argument to the `Tabs#get_stats` method.
 
     :minute, :hour, :day, :week, :month, :year
 
@@ -95,22 +156,30 @@ It automatically aggregates multiple events for the same period.  For instance w
 
 You can list all metrics using `list_metrics`:
 
-    Tabs.list_metrics #=> ["website-visits", "new-user-age"]
+```ruby
+Tabs.list_metrics #=> ["website-visits", "new-user-age"]
+```
 
 You can check a metric's type (counter of value) by calling
 `metric_type`:
 
-    Tabs.metric_type("website-visits") #=> "counter"
+```ruby
+Tabs.metric_type("website-visits") #=> "counter"
+```
 
 And you can quickly check if a metric exists:
 
-    Tabs.metric_exists?("foobar") #=> false
+```ruby
+Tabs.metric_exists?("foobar") #=> false
+```
 
 ### Drop a Metric
 
 To drop a metric, just call `Tabs#drop_metric`
 
-    Tabs.drop_metric(“website-visits”)
+```ruby
+Tabs.drop_metric("website-visits")
+```
     
 This will drop all recorded values for the metric so it may not be un-done...be careful.
 
@@ -118,15 +187,17 @@ This will drop all recorded values for the metric so it may not be un-done...be
 
 There really isn’t much to configure with Tabs, it just works out of the box.  You can use the following configure block to set the Redis connection instance that Tabs will use.
 
-    Tabs.configure do |config|
-    
-      # set it to an existing connection
-      config.redis = Redis.current
-      
-      # pass a config hash that will be passed to Redis.new
-      config.redis = { :host => 'localhost', :port => 6379 }
-      
-    end
+```ruby
+Tabs.configure do |config|
+
+  # set it to an existing connection
+  config.redis = Redis.current
+  
+  # pass a config hash that will be passed to Redis.new
+  config.redis = { :host => 'localhost', :port => 6379 }
+  
+end
+```
 
 ## Contributing
 

data/lib/tabs.rb

@@ -17,5 +17,7 @@ require "tabs/resolutions/year"
 
 require "tabs/metrics/counter"
 require "tabs/metrics/value"
+require "tabs/metrics/task"
+require "tabs/metrics/task/token"
 
 require "tabs/tabs"

data/lib/tabs/helpers.rb

@@ -2,15 +2,15 @@ module Tabs
   module Helpers
     extend self
 
-    def timestamp_range(period, resolution, default_value=0)
+    def timestamp_range(period, resolution)
       period = normalize_period(period, resolution)
       dt = period.first
-      Hash[([].tap do |arr|
+      [].tap do |arr|
         arr << dt
         while (dt = dt + 1.send(resolution)) <= period.last
           arr << dt.utc
         end
-      end).map { |ts| [ts, default_value] }]
+      end
     end
 
     def normalize_period(period, resolution)
@@ -25,10 +25,15 @@ module Tabs
     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])
+      all_timestamps = timestamp_range(period, resolution)
+      default_value_timestamps = Hash[all_timestamps.map { |t| [t, default_value] }]
+      merged = default_value_timestamps.merge(Hash[date_value_pairs])
       merged.to_a
     end
 
+    def round_float(f)
+      (f*100).round / 100.0
+    end
+
   end
 end

data/lib/tabs/metrics/counter.rb

@@ -1,8 +1,8 @@
 module Tabs
   module Metrics
     class Counter
-      include Tabs::Storage
-      include Tabs::Helpers
+      include Storage
+      include Helpers
 
       attr_reader :key
 
@@ -21,7 +21,7 @@ module Tabs
 
       def stats(period, resolution)
         period = normalize_period(period, resolution)
-        keys = smembers("stat:keys:#{key}:#{resolution}")
+        keys = smembers("stat:counter:#{key}:keys:#{resolution}")
         dates = keys.map { |k| extract_date_from_key(k, resolution) }
         values = mget(*keys).map(&:to_i)
         pairs = dates.zip(values)
@@ -31,20 +31,20 @@ module Tabs
       end
 
       def total
-        get("stat:#{key}:total").to_i
+        get("stat:counter:#{key}:total").to_i
       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)
+        stat_key = "stat:counter:#{key}:count:#{formatted_time}"
+        sadd("stat:counter:#{key}:keys:#{resolution}", stat_key)
         incr(stat_key)
       end
 
       def increment_total
-        incr("stat:#{key}:total")
+        incr("stat:counter:#{key}:total")
       end
 
     end

data/lib/tabs/metrics/task.rb

@@ -0,0 +1,51 @@
+module Tabs
+  module Metrics
+    class Task
+      include Tabs::Storage
+      include Tabs::Helpers
+
+      class UnstartedTaskMetricError < Exception; end
+
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+      end
+
+      def start(token)
+        Token.new(token, key).start
+        true
+      end
+
+      def complete(token)
+        Token.new(token, key).complete
+        true
+      end
+
+      def stats(period, resolution)
+        range = timestamp_range(period, resolution)
+        started_tokens = tokens_for_period(range, resolution, "started")
+        completed_tokens = tokens_for_period(range, resolution, "completed")
+        matching_tokens = started_tokens & completed_tokens
+        completion_rate = round_float(matching_tokens.size.to_f / range.size)
+        elapsed_times = matching_tokens.map { |t| t.time_elapsed(resolution) }
+        average_completion_time = (elapsed_times.inject(&:+)) / matching_tokens.size
+        {
+          started: started_tokens.size,
+          completed: completed_tokens.size,
+          completed_within_period: matching_tokens.size,
+          completion_rate: completion_rate,
+          average_completion_time: average_completion_time
+        }
+      end
+
+      private
+
+      def tokens_for_period(range, resolution, type)
+        keys = Task::Token.keys_for_range(key, range, resolution, type)
+        mget(*keys).compact.map(&:to_a).flatten.map { |t| Token.new(t, key) }
+      end
+
+    end
+  end
+end

data/lib/tabs/metrics/task/token.rb

@@ -0,0 +1,80 @@
+module Tabs
+  module Metrics
+    class Task
+      class Token < String
+        include Storage
+
+        def self.keys_for_range(key, range, resolution, type)
+          range.map do |date|
+            formatted_time = Tabs::Resolution.serialize(resolution, date)
+            "stat:task:#{key}:#{type}:#{formatted_time}"
+          end
+        end
+
+        attr_reader :key
+
+        def initialize(token, key)
+          @key = key
+          super(token)
+        end
+
+        def start_key
+          "stat:started:#{key}:#{self}"
+        end
+
+        def end_key
+          "stat:completed:#{key}:#{self}"
+        end
+
+        def start
+          self.start_time = Time.now.utc
+          sadd("stat:task:#{key}:tokens", self)
+          Tabs::RESOLUTIONS.each { |res| record_start(res, start_time) }
+        end
+
+        def complete
+          unless sismember("stat:task:#{key}:tokens", self)
+            raise UnstartedTaskMetricError.new("No task for metric '#{key}' was started with token '#{self}'")
+          end
+          self.complete_time = Time.now.utc
+          Tabs::RESOLUTIONS.each { |res| record_complete(res, complete_time) }
+        end
+
+        def time_elapsed(resolution)
+          Tabs::Resolution.from_seconds(resolution, complete_time - start_time)
+        end
+
+        private
+
+        def record_start(resolution, timestamp)
+          formatted_time = Tabs::Resolution.serialize(resolution, timestamp)
+          sadd("stat:task:#{key}:started:#{formatted_time}", self)
+        end
+
+        def record_complete(resolution, timestamp)
+          formatted_time = Tabs::Resolution.serialize(resolution, timestamp)
+          sadd("stat:task:#{key}:completed:#{formatted_time}", self)
+        end
+
+        def start_time=(timestamp)
+          set("stat:task:#{key}:#{self}:started_time", timestamp)
+          @start_time = timestamp
+        end
+
+        def start_time
+          @start_time ||= Time.parse(get("stat:task:#{key}:#{self}:started_time"))
+        end
+
+        def complete_time=(timestamp)
+          set("stat:task:#{key}:#{self}:completed_time", timestamp)
+          @complete_time = timestamp
+        end
+
+        def complete_time
+          @complete_time ||= Time.parse(get("stat:task:#{key}:#{self}:completed_time"))
+        end
+
+      end
+    end
+  end
+end

data/lib/tabs/metrics/value.rb

@@ -1,8 +1,8 @@
 module Tabs
   module Metrics
     class Value
-      include Tabs::Storage
-      include Tabs::Helpers
+      include Storage
+      include Helpers
 
       attr_reader :key
 
@@ -14,8 +14,8 @@ module Tabs
         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)
+          stat_key = "stat:value:#{key}:data:#{formatted_time}"
+          sadd("stat:value:#{key}:keys:#{resolution}", stat_key)
           update_values(stat_key, value)
         end
         true
@@ -23,7 +23,7 @@ module Tabs
 
       def stats(period, resolution)
         period = normalize_period(period, resolution)
-        keys = smembers("stat:keys:#{key}:#{resolution}")
+        keys = smembers("stat:value:#{key}:keys:#{resolution}")
         dates = keys.map { |k| extract_date_from_key(k, resolution) }
         values = mget(*keys).map { |v| JSON.parse(v) }
         pairs = dates.zip(values)

data/lib/tabs/resolution.rb

@@ -10,6 +10,10 @@ module Tabs
       resolution_klass(resolution).deserialize(str)
     end
 
+    def from_seconds(resolution, s)
+      resolution_klass(resolution).from_seconds(s)
+    end
+
     def normalize(resolution, timestamp)
       resolution_klass(resolution).normalize(timestamp)
     end

data/lib/tabs/resolutions/day.rb

@@ -14,6 +14,10 @@ module Tabs
         self.normalize(dt)
       end
 
+      def from_seconds(s)
+        s / 86400
+      end
+
       def normalize(ts)
         Time.utc(ts.year, ts.month, ts.day)
       end

data/lib/tabs/resolutions/hour.rb

@@ -14,6 +14,10 @@ module Tabs
         self.normalize(dt)
       end
 
+      def from_seconds(s)
+        s / 3600
+      end
+
       def normalize(ts)
         Time.utc(ts.year, ts.month, ts.day, ts.hour)
       end

data/lib/tabs/resolutions/minute.rb

@@ -14,6 +14,10 @@ module Tabs
         self.normalize(dt)
       end
 
+      def from_seconds(s)
+        s / 60.0
+      end
+
       def normalize(ts)
         Time.utc(ts.year, ts.month, ts.day, ts.hour, ts.min)
       end

data/lib/tabs/resolutions/month.rb

@@ -14,6 +14,10 @@ module Tabs
         self.normalize(dt)
       end
 
+      def from_seconds(s)
+        s / 1728000
+      end
+
       def normalize(ts)
         Time.utc(ts.year, ts.month)
       end

data/lib/tabs/resolutions/week.rb

@@ -16,6 +16,10 @@ module Tabs
         self.normalize(dt)
       end
 
+      def from_seconds(s)
+        s / 432000
+      end
+
       def normalize(ts)
         Time.utc(ts.year, ts.month, ts.day).beginning_of_week
       end

data/lib/tabs/resolutions/year.rb

@@ -14,6 +14,10 @@ module Tabs
         self.normalize(dt)
       end
 
+      def from_seconds(s)
+        s / 31536000
+      end
+
       def normalize(ts)
         Time.utc(ts.year)
       end

data/lib/tabs/storage.rb

@@ -44,6 +44,10 @@ module Tabs
       redis.smembers("tabs:#{key}")
     end
 
+    def sismember(key, value)
+      redis.sismember("tabs:#{key}", value)
+    end
+
     def hget(key, field)
       redis.hget("tabs:#{key}", field)
     end

data/lib/tabs/tabs.rb

@@ -7,7 +7,7 @@ module Tabs
   class UnknownMetricError < Exception; end
   class MetricTypeMismatchError < Exception; end
 
-  METRIC_TYPES = ["counter", "value"]
+  METRIC_TYPES = ["counter", "value", "task"]
 
   RESOLUTIONS = [:minute, :hour, :day, :week, :month, :year]
 
@@ -35,6 +35,17 @@ module Tabs
     get_metric(key).record(value)
   end
 
+  def start_task(key, token)
+    create_metric(key, "task")
+    raise MetricTypeMismatchError.new("Only task metrics can start a task") unless metric_type(key) == "task"
+    get_metric(key).start(token)
+  end
+
+  def complete_task(key, token)
+    raise MetricTypeMismatchError.new("Only task metrics can complete a task") unless metric_type(key) == "task"
+    get_metric(key).complete(token)
+  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)

data/lib/tabs/version.rb

@@ -1,3 +1,3 @@
 module Tabs
-  VERSION = "0.5.6"
+  VERSION = "0.6.1"
 end

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

@@ -14,6 +14,7 @@ describe Tabs::Metrics::Counter do
       stats = metric.stats(((now - 2.hours)..(now + 4.hours)), :hour)
       expect(stats).to include({ time => 1 })
     end
+
   end
 
   describe "total count" do

data/spec/lib/tabs/task_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe Tabs::Metrics::Task do
+
+  let(:metric) { Tabs.create_metric("foo", "task") }
+  let(:now) { Time.utc(2000, 1, 1, 0, 0) }
+  let(:token_1) { "2gd7672gjh3" }
+  let(:token_2) { "17985jh34gj" }
+  let(:token_3) { "27f98fhgh1x" }
+
+  describe ".start" do
+
+  end
+
+  describe ".complete" do
+
+    it "raises an UnstartedTaskMetricError if the metric has not yet been started" do
+      lambda { metric.complete("foobar") }.should raise_error(Tabs::Metrics::Task::UnstartedTaskMetricError)
+    end
+
+  end
+
+  describe ".stats" do
+
+    it "returns the expected value" do
+      Timecop.freeze(now)
+      metric.start(token_1)
+      metric.start(token_2)
+      Timecop.freeze(now + 2.minutes)
+      metric.complete(token_1)
+      metric.start(token_3)
+      Timecop.freeze(now + 3.minutes)
+      metric.complete(token_3)
+      stats = metric.stats((now - 5.minutes)..(now + 5.minutes), :minute)
+      expect(stats).to eq(
+        {
+          started: 3,
+          completed: 2,
+          completed_within_period: 2,
+          completion_rate: 0.18,
+          average_completion_time: 1.5
+        }
+      )
+    end
+
+  end
+
+end

data/spec/lib/tabs_spec.rb

@@ -25,8 +25,10 @@ describe Tabs do
     it "adds the metric's key to the list_metrics" do
       Tabs.create_metric("foo", "value")
       Tabs.create_metric("bar", "counter")
+      Tabs.create_metric("baz", "task")
       expect(Tabs.list_metrics).to include("foo")
       expect(Tabs.list_metrics).to include("bar")
+      expect(Tabs.list_metrics).to include("baz")
     end
 
   end
@@ -78,7 +80,7 @@ describe Tabs do
     it "removes the metrics values from redis" do
       Tabs.increment_counter("foo")
       keys = smembers("tabs:stat:keys:foo:hour")
-      expect(redis.keys).to include("tabs:stat:keys:foo:hour")
+      expect(redis.keys).to include("tabs:stat:counter:foo:keys:hour")
       Tabs.drop_metric("foo")
       expect(redis.keys).to_not include(keys[0])
     end

data/tabs.gemspec

@@ -18,6 +18,13 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.post_install_message = <<TXT
+**** NOTICE ****
+Please note there are breaking changes in this version of tabs!
+Existing data cannot be read because of changes to the redis key patterns.
+Please continue to use version 0.5.6 if you need to access existing metric data."
+TXT
+
   gem.add_dependency "activesupport", ">= 3.2.12"
   gem.add_dependency "json", "~> 1.7.7"
   gem.add_dependency "redis", "~> 3.0.2"

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: tabs
 version: !ruby/object:Gem::Version
-  version: 0.5.6
-  prerelease: 
+  version: 0.6.1
 platform: ruby
 authors:
 - JC Grubbs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-09 00:00:00.000000000 Z
+date: 2013-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -46,7 +41,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -54,7 +48,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -62,7 +55,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: fakeredis
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -70,7 +62,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -78,7 +69,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -86,7 +76,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -94,7 +83,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -102,7 +90,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -110,7 +97,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -118,7 +104,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -126,7 +111,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -134,7 +118,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -158,6 +141,8 @@ files:
 - lib/tabs/config.rb
 - lib/tabs/helpers.rb
 - lib/tabs/metrics/counter.rb
+- lib/tabs/metrics/task.rb
+- lib/tabs/metrics/task/token.rb
 - lib/tabs/metrics/value.rb
 - lib/tabs/resolution.rb
 - lib/tabs/resolutions/day.rb
@@ -171,36 +156,45 @@ files:
 - lib/tabs/version.rb
 - spec/lib/tabs/metrics/counter_spec.rb
 - spec/lib/tabs/metrics/value_spec.rb
+- spec/lib/tabs/task_spec.rb
 - spec/lib/tabs_spec.rb
 - spec/spec_helper.rb
 - tabs.gemspec
 homepage: https://github.com/thegrubbsian/tabs
 licenses: []
-post_install_message: 
+metadata: {}
+post_install_message: ! '**** NOTICE ****
+
+  Please note there are breaking changes in this version of tabs!
+
+  Existing data cannot be read because of changes to the redis key patterns.
+
+  Please continue to use version 0.5.6 if you need to access existing metric data."
+
+'
 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
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 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/task_spec.rb
 - spec/lib/tabs_spec.rb
 - spec/spec_helper.rb
 has_rdoc: