tabstabs 2.0.0

data/spec/lib/tabs_tabs/metrics/value/stats_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe TabsTabs::Metrics::Value::Stats do
+
+  let(:period) { (Time.now - 2.days..Time.now) }
+  let(:resolution) { :hour }
+  let(:values) do
+    [
+      { "timestamp" => Time.now - 30.hours, "count" => 10, "sum" => 145, "min" => 11, "max" => 204, "avg" => 14.5 },
+      { "timestamp" => Time.now - 20.hours, "count" => 15, "sum" => 288, "min" => 10, "max" => 199, "avg" => 19.2 },
+      { "timestamp" => Time.now - 10.hours, "count" => 25, "sum" => 405, "min" => 12, "max" => 210, "avg" => 16.2 }
+    ]
+  end
+  let(:stats) { TabsTabs::Metrics::Value::Stats.new(period, resolution, values) }
+
+  it "is enumerable" do
+    expect(stats).to respond_to :each
+    expect(TabsTabs::Metrics::Value::Stats.ancestors).to include Enumerable
+  end
+
+  it "#count returns the total count for the entire set" do
+    expect(stats.count).to eq 50
+  end
+
+  it "sum returns the sum for the entire set" do
+    expect(stats.sum).to eq 838
+  end
+
+  it "min returns the min for the entire set" do
+    expect(stats.min).to eq 10
+  end
+
+  it "max returns the max for the entire set" do
+    expect(stats.max).to eq 210
+  end
+
+  it "avg returns the average for the entire set" do
+    expect(stats.avg).to eq 16.76
+  end
+
+  it "avg returns 0 if set is empty" do
+    stats = TabsTabs::Metrics::Value::Stats.new(period, resolution, [])
+    expect(stats.avg).to be_zero
+  end
+
+  context "override decimal precision" do
+    before do
+      @precision = TabsTabs.config.decimal_precision
+      TabsTabs.config.decimal_precision = 1
+    end
+
+    after do
+      TabsTabs.config.decimal_precision = @precision
+    end
+
+    it "allows you to override decimal precision" do
+      expect(stats.avg).to eq 16.8
+    end
+  end
+
+end

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

@@ -0,0 +1,160 @@
+require "spec_helper"
+
+describe TabsTabs::Metrics::Value do
+
+  include TabsTabs::Storage
+
+  let(:metric) { TabsTabs.create_metric("foo", "value") }
+  let(:now) { Time.utc(2000, 1, 1, 0, 0) }
+
+  describe ".record" do
+
+    before { Timecop.freeze(now) }
+
+    it "sets the expected values for the period" do
+      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({ "timestamp"=>time, "count"=>2, "min"=>17, "max"=>42, "sum"=>59, "avg"=>29.5})
+    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({ "timestamp"=>time, "count"=>1, "min"=>42, "max"=>42, "sum"=>42, "avg"=>42})
+    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 + 1.send(time_unit))
+      metric.record(25)
+      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 an instance of Tabs::Metrics::Value::Stats" do
+      create_span(:minutes)
+      stats = metric.stats(now..(now + 7.minutes), :minute)
+      expect(stats).to be_a_kind_of TabsTabs::Metrics::Value::Stats
+    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({ "timestamp" => (now + 3.minutes), "count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10})
+      expect(stats).to include({ "timestamp" => (now + 6.minutes), "count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17.5})
+    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({ "timestamp" => (now + 3.hours), "count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10})
+      expect(stats).to include({ "timestamp" => (now + 6.hours), "count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17.5})
+    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({ "timestamp" => (now + 3.days), "count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10})
+      expect(stats).to include({ "timestamp" => (now + 6.days), "count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17.5})
+    end
+
+    it "returns the expected results for a weekly metric" do
+      create_span(:weeks)
+      stats = metric.stats(now..(now + 7.weeks), :week)
+      second_week_stats = stats.detect{|s| s["timestamp"] == (now + 1.week).beginning_of_week }
+      expect(second_week_stats["count"]).to eq(1)
+      expect(stats).to include({ "timestamp" => (now + 3.weeks).beginning_of_week, "count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10})
+      expect(stats).to include({ "timestamp" => (now + 6.weeks).beginning_of_week, "count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17.5})
+    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({ "timestamp" => (now + 3.months), "count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10})
+      expect(stats).to include({ "timestamp" => (now + 6.months), "count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17.5})
+    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({ "timestamp" => (now + 3.years), "count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10})
+      expect(stats).to include({ "timestamp" => (now + 6.years), "count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17.5})
+    end
+  end
+
+  describe ".drop!" do
+
+    before do
+      3.times { metric.record(rand(30)) }
+      @count_keys = (TabsTabs::Resolution.all.map do |res|
+        smembers("stat:value:foo:keys:#{res}")
+      end).flatten
+      metric.drop!
+    end
+
+    it "deletes all resolution count keys" do
+      @count_keys.each do |key|
+        expect(exists(key)).to be_false
+      end
+    end
+
+    it "deletes all resolution key collection keys" do
+      TabsTabs::Resolution.all.each do |res|
+        expect(exists("stat:value:foo:keys:#{res}")).to be_falsey
+      end
+    end
+
+  end
+
+  describe ".drop_by_resolution!" do
+    before do
+      Timecop.freeze(now)
+      2.times { metric.record(rand(30)) }
+      metric.drop_by_resolution!(:minute)
+    end
+
+    it "deletes all metrics for a resolution" do
+      stats = metric.stats((now - 1.minute)..(now + 1.minute), :minute)
+      expect(stats.sum).to eq(0)
+    end
+  end
+
+  describe "expiration of value metrics" do
+    let(:expires_setting){ 6.hours }
+    let(:now){ Time.utc(2050, 1, 1, 0, 0) }
+
+    before do
+      TabsTabs::Config.set_expirations({minute: expires_setting })
+    end
+
+    after do
+      TabsTabs::Config.reset_expirations
+    end
+
+    it "sets an expiration when recording a value" do
+      metric.record(17, now)
+      redis_expire_date = Time.now + TabsTabs::Storage.ttl(metric.storage_key(:minute, now))
+      expire_date = now + expires_setting + TabsTabs::Resolutions::Minute.to_seconds
+      expect(redis_expire_date).to be_within(2.seconds).of(expire_date)
+    end
+  end
+end

data/spec/lib/tabs_tabs/resolution_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+require File.expand_path("../../../support/custom_resolutions", __FILE__)
+
+describe TabsTabs::Resolution do
+
+  describe "#register" do
+    it "registers a new resolution" do
+      TabsTabs::Resolution.register(WellFormedResolution)
+      expect(TabsTabs::Resolution.all).to include WellFormedResolution.name
+    end
+
+    context "with a custom resolution" do
+      it "does not return nil" do
+        expect(WellFormedResolution.serialize(Time.now)).to_not be_nil
+      end
+
+      it "gets stats for custom resolution" do
+        TabsTabs::Resolution.register(WellFormedResolution)
+        Timecop.freeze(Time.now)
+
+        TabsTabs.increment_counter("foo")
+        expect(TabsTabs.get_stats("foo", (Time.now - 5.seconds..Time.now), :seconds).values.size).to eq(6)
+      end
+
+      it "raises an error when method not implemented" do
+        expect{BadlyFormedResolution.normalize}.to raise_error(RuntimeError)
+      end
+
+      it "disregards already registered resolutions" do
+        expect { TabsTabs::Resolution.register(TabsTabs::Resolutions::Minute) }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#unregister" do
+    it "unregisters a single resolution" do
+      TabsTabs::Resolution.unregister(:minute)
+      expect(TabsTabs::Resolution.all).to_not include(:minute)
+    end
+
+    it "unregisters an array of resolutions" do
+      TabsTabs::Resolution.unregister([:minute, :hour])
+      expect(TabsTabs::Resolution.all).to_not include(:hour)
+      expect(TabsTabs::Resolution.all).to_not include(:minute)
+    end
+
+    it "disregards passing in an unrecognized resolution" do
+      expect { TabsTabs::Resolution.unregister(:invalid_resolution) }.to_not raise_error
+    end
+  end
+
+end

data/spec/lib/tabs_tabs/resolutionable_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe TabsTabs::Resolutionable do
+
+  module TestResolution
+    include TabsTabs::Resolutionable
+    extend self
+
+    def name
+      :test
+    end
+
+    def to_seconds
+      1000
+    end
+
+  end
+
+  describe "interface exceptions" do
+
+    ["serialize", "deserialize", "from_seconds", "add", "normalize"].each do |method|
+      it "are raised when the #{method} method is not implemented" do
+        expect { TestResolution.send(method) }.to raise_error(RuntimeError)
+      end
+    end
+
+  end
+
+  describe "#expire" do
+    let(:expires_setting){ 1.day }
+
+    before do
+      TabsTabs::Config.register_resolution(TestResolution)
+      TabsTabs::Config.set_expirations(test: expires_setting)
+    end
+
+    after do
+      TabsTabs::Config.reset_expirations
+      TabsTabs::Config.unregister_resolutions(:test)
+    end
+
+    it "sets the expiration for the given key" do
+      now = Time.utc(2050, 1, 1, 0, 0, 0)
+      TabsTabs::Storage.set("foo", "bar")
+      TestResolution.expire("foo", now)
+      redis_expire_date = Time.now + TabsTabs::Storage.ttl("foo")
+      expire_date = now + expires_setting + TestResolution.to_seconds
+      expect(redis_expire_date).to be_within(2.seconds).of(expire_date)
+    end
+
+  end
+
+end

data/spec/lib/tabs_tabs/resolutions/day_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe TabsTabs::Resolutions::Day do
+  let(:timestamp){ Time.new(2000, 1, 1, 12, 15) }
+
+  context "#normalize" do
+    it "should normalize the date to year, month, day" do
+      expect(subject.normalize(timestamp)).to eq(timestamp.utc.change(hour: 0))
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY-MM-DD" do
+      expect(subject.serialize(timestamp)).to eq("2000-01-01")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert string into date" do
+      expect(subject.deserialize("2000-01-01")).to eq(timestamp.utc.change(hour: 0))
+    end
+  end
+end

data/spec/lib/tabs_tabs/resolutions/hour_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe TabsTabs::Resolutions::Hour do
+  let(:timestamp){ Time.utc(2000, 1, 1, 14, 12) }
+
+  context "#normalize" do
+    it "should normalize the date to year, month, day, hour" do
+      expect(subject.normalize(timestamp)).to eq(timestamp.change(min: 0))
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY-MM-DD-HH" do
+      expect(subject.serialize(timestamp)).to eq("2000-01-01-14")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert string into date" do
+      expect(subject.deserialize("2000-01-01-14")).to eq(timestamp.change(min: 0))
+    end
+  end
+end

data/spec/lib/tabs_tabs/resolutions/minute_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe TabsTabs::Resolutions::Minute do
+  let(:timestamp){ Time.utc(2000, 1, 1, 14, 12, 44) }
+
+  context "#normalize" do
+    it "should normalize the date to year, month, day, hour, minute" do
+      expect(subject.normalize(timestamp)).to eq(timestamp.change(sec: 0))
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY-MM-DD-HH-MM" do
+      expect(subject.serialize(timestamp)).to eq("2000-01-01-14-12")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert string into date" do
+      expect(subject.deserialize("2000-01-01-14-12")).to eq(timestamp.change(sec: 0))
+    end
+  end
+end

data/spec/lib/tabs_tabs/resolutions/month_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe TabsTabs::Resolutions::Month do
+  let(:timestamp){ Time.utc(2000, 1, 15) }
+
+  context "#normalize" do
+    it "should normalize the date to year, month" do
+      expect(subject.normalize(timestamp)).to eq(timestamp.change(day: 1))
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY-MM" do
+      expect(subject.serialize(timestamp)).to eq("2000-01")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert string into date" do
+      expect(subject.deserialize("2000-01")).to eq(timestamp.change(day: 1))
+    end
+  end
+end

data/spec/lib/tabs_tabs/resolutions/week_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe TabsTabs::Resolutions::Week do
+  let(:timestamp){ Time.utc(2000, 1, 1) }
+  let(:beginning_of_week_timestamp){ Time.utc(1999, 12, 27) }
+
+  context "#normalize" do
+    it "should roll to the beginning of the week" do
+      expect(subject.normalize(timestamp)).to eq(beginning_of_week_timestamp)
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY-MM-DD based on beginning of the week" do
+      expect(subject.serialize(timestamp)).to eq("1999-12-27")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert beginning of week string into date" do
+      expect(subject.deserialize("1999-12-27")).to eq(beginning_of_week_timestamp)
+    end
+  end
+end