tabs 0.6.3 → 0.7.0

data/README.md

@@ -9,7 +9,7 @@ averages, and min/max, and task based stats sliceable by the minute, hour, day,
 
 Add this line to your application's Gemfile:
 
-    gem 'tabs', '~> 0.6.3'
+    gem 'tabs', '~> 0.6.2'
 
 And then execute:
 

data/lib/tabs/metrics/counter.rb

@@ -10,8 +10,8 @@ module Tabs
         @key = key
       end
 
-      def increment
-        timestamp = Time.now.utc
+      def increment(timestamp=Time.now)
+        timestamp.utc
         Tabs::RESOLUTIONS.each do |resolution|
           increment_resolution(resolution, timestamp)
         end

data/lib/tabs/metrics/task.rb

@@ -12,13 +12,13 @@ module Tabs
         @key = key
       end
 
-      def start(token)
-        Token.new(token, key).start
+      def start(token, timestamp=Time.now)
+        Token.new(token, key).start(timestamp)
         true
       end
 
-      def complete(token)
-        Token.new(token, key).complete
+      def complete(token, timestamp=Time.now)
+        Token.new(token, key).complete(timestamp)
         true
       end
 
@@ -46,10 +46,17 @@ module Tabs
       private
 
       def tokens_for_period(range, resolution, type)
-        keys = Task::Token.keys_for_range(key, range, resolution, type)
+        keys = keys_for_range(range, resolution, type)
         mget(*keys).compact.map(&:to_a).flatten.map { |t| Token.new(t, key) }
       end
 
+      def keys_for_range(range, resolution, type)
+        range.map do |date|
+          formatted_time = Tabs::Resolution.serialize(resolution, date)
+          "stat:task:#{key}:#{type}:#{formatted_time}"
+        end
+      end
+
     end
   end
 end

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

@@ -4,13 +4,6 @@ module Tabs
       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)
@@ -18,25 +11,17 @@ module Tabs
           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
+        def start(timestamp=Time.now)
+          self.start_time = timestamp.utc
           sadd("stat:task:#{key}:tokens", self)
           Tabs::RESOLUTIONS.each { |res| record_start(res, start_time) }
         end
 
-        def complete
+        def complete(timestamp=Time.now)
+          self.complete_time = timestamp.utc
           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
 

data/lib/tabs/metrics/value.rb

@@ -10,8 +10,8 @@ module Tabs
         @key = key
       end
 
-      def record(value)
-        timestamp = Time.now.utc
+      def record(value, timestamp=Time.now)
+        timestamp.utc
         Tabs::RESOLUTIONS.each do |resolution|
           formatted_time = Tabs::Resolution.serialize(resolution, timestamp)
           stat_key = "stat:value:#{key}:data:#{formatted_time}"

data/lib/tabs/tabs.rb

@@ -23,27 +23,27 @@ module Tabs
     Config
   end
 
-  def increment_counter(key)
+  def increment_counter(key, timestamp=Time.now)
     create_metric(key, "counter") unless metric_exists?(key)
     raise MetricTypeMismatchError.new("Only counter metrics can be incremented") unless metric_type(key) == "counter"
-    get_metric(key).increment
+    get_metric(key).increment(timestamp)
   end
 
-  def record_value(key, value)
+  def record_value(key, value, timestamp=Time.now)
     create_metric(key, "value") unless metric_exists?(key)
     raise MetricTypeMismatchError.new("Only value metrics can record a value") unless metric_type(key) == "value"
-    get_metric(key).record(value)
+    get_metric(key).record(value, timestamp)
   end
 
-  def start_task(key, token)
+  def start_task(key, token, timestamp=Time.now)
     create_metric(key, "task")
     raise MetricTypeMismatchError.new("Only task metrics can start a task") unless metric_type(key) == "task"
-    get_metric(key).start(token)
+    get_metric(key).start(token, timestamp)
   end
 
-  def complete_task(key, token)
+  def complete_task(key, token, timestamp=Time.now)
     raise MetricTypeMismatchError.new("Only task metrics can complete a task") unless metric_type(key) == "task"
-    get_metric(key).complete(token)
+    get_metric(key).complete(token, timestamp)
   end
 
   def create_metric(key, type)

data/lib/tabs/version.rb

@@ -1,3 +1,3 @@
 module Tabs
-  VERSION = "0.6.3"
+  VERSION = "0.7.0"
 end

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

@@ -9,14 +9,22 @@ describe Tabs::Metrics::Counter do
 
   describe "incrementing stats" do
 
+    before { Timecop.freeze(now) }
+
     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
 
+    it "applys the increment to the specified timestamp if one is supplied" do
+      time = Time.utc(now.year, now.month, now.day, now.hour) - 2.hours
+      metric.increment(time)
+      stats = metric.stats(((now - 3.hours)..now), :hour)
+      expect(stats).to include({ time => 1 })
+    end
+
   end
 
   describe "total count" do

data/spec/lib/tabs/metrics/task/token_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Tabs::Metrics::Task::Token do
+
+  describe "#time_elapsed" do
+
+    let(:token) { Tabs::Metrics::Task::Token.new("foo", "bar") }
+    let(:time) { Time.now }
+
+    it "should return the time between when the task/token started and completed" do
+      token.start(time - 2.days)
+      token.complete(time - 1.day)
+      expect(token.time_elapsed(:hour)).to eq(24)
+    end
+
+  end
+
+end

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

@@ -9,8 +9,9 @@ describe Tabs::Metrics::Value do
 
   describe ".record" do
 
+    before { Timecop.freeze(now) }
+
     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)
@@ -18,6 +19,13 @@ describe Tabs::Metrics::Value do
       expect(stats).to include({ time => {"count"=>2, "min"=>17, "max"=>42, "sum"=>59, "avg"=>29} })
     end
 
+    it "applys the value to the specified timestamp if one is supplied" do
+      time = Time.utc(now.year, now.month, now.day, now.hour) - 2.hours
+      metric.record(42, time)
+      stats = metric.stats(((now - 3.hours)..now), :hour)
+      expect(stats).to include({ time => {"count"=>1, "min"=>42, "max"=>42, "sum"=>42, "avg"=>42} })
+    end
+
   end
 
   describe ".stats" do

data/spec/lib/tabs/task_spec.rb

@@ -10,10 +10,41 @@ describe Tabs::Metrics::Task do
 
   describe ".start" do
 
+    let(:token) { stub(:token) }
+    let(:time) { Time.now }
+
+    it "calls start on the given token" do
+      Tabs::Metrics::Task::Token.should_receive(:new).with(token_1, "foo").and_return(token)
+      token.should_receive(:start)
+      metric.start(token_1)
+    end
+
+    it "passes through the specified timestamp" do
+      Tabs::Metrics::Task::Token.stub(new: token)
+      token.should_receive(:start).with(time)
+      metric.start(token_1, time)
+    end
+
   end
 
   describe ".complete" do
 
+    let(:token) { stub(:token) }
+    let(:time) { Time.now }
+
+    it "calls complete on the given token" do
+      token = stub(:token)
+      Tabs::Metrics::Task::Token.should_receive(:new).with(token_1, "foo").and_return(token)
+      token.should_receive(:complete)
+      metric.complete(token_1)
+    end
+
+    it "passes through the specified timestamp" do
+      Tabs::Metrics::Task::Token.stub(new: token)
+      token.should_receive(:complete).with(time)
+      metric.complete(token_1, time)
+    end
+
     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

data/spec/lib/tabs_spec.rb

@@ -128,7 +128,7 @@ describe Tabs do
     it "calls record on the metric" do
       metric = Tabs.create_metric("foo", "value")
       Tabs.stub(get_metric: metric)
-      metric.should_receive(:record).with(42)
+      metric.should_receive(:record).with(42, Time.now.utc)
       Tabs.record_value("foo", 42)
     end
 
@@ -142,7 +142,7 @@ describe Tabs do
       Tabs.create_metric("baz", "counter")
       expect(Tabs.list_metrics).to eq(["foo", "bar", "baz"])
     end
-    
+
   end
 
   describe "#metric_type" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tabs
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-17 00:00:00.000000000 Z
+date: 2013-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -172,6 +172,7 @@ files:
 - lib/tabs/tabs.rb
 - lib/tabs/version.rb
 - spec/lib/tabs/metrics/counter_spec.rb
+- spec/lib/tabs/metrics/task/token_spec.rb
 - spec/lib/tabs/metrics/value_spec.rb
 - spec/lib/tabs/task_spec.rb
 - spec/lib/tabs_spec.rb
@@ -211,8 +212,8 @@ 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/task/token_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: