tabs 0.9.1 → 1.0.0

data/lib/tabs/resolution.rb

@@ -1,11 +1,16 @@
 module Tabs
   module Resolution
-    extend Resolutionable
+    include Resolutionable
     extend self
 
-    def register(resolution, klass)
+    def register(klass)
       @@resolution_classes ||= {}
-      @@resolution_classes[resolution] = klass
+      @@resolution_classes[klass.name] = klass
+    end
+
+    def unregister(resolutions)
+      resolutions = Array[resolutions].flatten
+      resolutions.each{ |res| @@resolution_classes.delete(res) }
     end
 
     def serialize(resolution, timestamp)
@@ -32,18 +37,29 @@ module Tabs
       @@resolution_classes.keys
     end
 
+    def expire(resolution, key, timestamp)
+      resolution_klass(resolution).expire(key, timestamp)
+    end
+
+    def reset_default_resolutions
+      @@resolution_classes = {}
+      Tabs::Resolution.register(Tabs::Resolutions::Minute)
+      Tabs::Resolution.register(Tabs::Resolutions::Hour)
+      Tabs::Resolution.register(Tabs::Resolutions::Day)
+      Tabs::Resolution.register(Tabs::Resolutions::Week)
+      Tabs::Resolution.register(Tabs::Resolutions::Month)
+      Tabs::Resolution.register(Tabs::Resolutions::Year)
+    end
+
     private
 
     def resolution_klass(resolution)
-      @@resolution_classes[resolution]
+      klass = @@resolution_classes[resolution]
+      raise Tabs::ResolutionMissingError.new(resolution) unless klass
+      klass
     end
 
   end
 end
 
-Tabs::Resolution.register(:minute, Tabs::Resolutions::Minute)
-Tabs::Resolution.register(:hour, Tabs::Resolutions::Hour)
-Tabs::Resolution.register(:day, Tabs::Resolutions::Day)
-Tabs::Resolution.register(:week, Tabs::Resolutions::Week)
-Tabs::Resolution.register(:month, Tabs::Resolutions::Month)
-Tabs::Resolution.register(:year, Tabs::Resolutions::Year)
+Tabs::Resolution.reset_default_resolutions

data/lib/tabs/resolutionable.rb

@@ -1,25 +1,48 @@
 module Tabs
   module Resolutionable
-    extend self
 
-    def serialize
-      raise "Must implement serialize in the concrete resolution module"
+    def self.included(base)
+      base.extend ClassMethods
     end
 
-    def deserialize
-      raise "Must implement deserialize in the concrete resolution module"
-    end
+    module ClassMethods
 
-    def from_seconds
-      raise "Must implement from_seconds in the concrete resolution module"
-    end
+      def name
+        raise "Must implement #name in the concrete resolution module"
+      end
+
+      def serialize
+        raise "Must implement #serialize in the concrete resolution module"
+      end
+
+      def deserialize
+        raise "Must implement #deserialize in the concrete resolution module"
+      end
+
+      def from_seconds
+        raise "Must implement #from_seconds in the concrete resolution module"
+      end
+
+      def to_seconds
+        raise "Must implement #to_seconds in the concrete resolution module"
+      end
+
+      def add
+        raise "Must implement #to_seconds in the concrete resolution module"
+      end
+
+      def normalize
+        raise "Must implement #normalize in the concrete resolution module"
+      end
 
-    def add
-      raise "Must implement to_seconds in the concrete resolution module"
     end
 
-    def normalize
-      raise "Must implement normalize in the concrete resolution module"
+    def expire(key, timestamp)
+      return unless Tabs::Config.expires?(name)
+      resolution_ends_at = timestamp.utc.to_i + to_seconds
+      expires_at = resolution_ends_at + Tabs::Config.expires_in(name)
+      Storage.expireat(key, expires_at)
     end
+
   end
 end

data/lib/tabs/resolutions/day.rb

@@ -1,11 +1,15 @@
 module Tabs
   module Resolutions
     module Day
-      extend Resolutionable
+      include Tabs::Resolutionable
       extend self
 
       PATTERN = "%Y-%m-%d"
 
+      def name
+        :day
+      end
+
       def serialize(timestamp)
         timestamp.strftime(PATTERN)
       end
@@ -19,6 +23,10 @@ module Tabs
         s / 1.day
       end
 
+      def to_seconds
+        1.day
+      end
+
       def add(ts, num)
         ts + num.days
       end

data/lib/tabs/resolutions/hour.rb

@@ -1,11 +1,15 @@
 module Tabs
   module Resolutions
     module Hour
-      extend Tabs::Resolutionable
+      include Tabs::Resolutionable
       extend self
 
       PATTERN = "%Y-%m-%d-%H"
 
+      def name
+        :hour
+      end
+
       def serialize(timestamp)
         timestamp.strftime(PATTERN)
       end
@@ -19,6 +23,10 @@ module Tabs
         s / 1.hour
       end
 
+      def to_seconds
+        1.hour
+      end
+
       def add(ts, num)
         ts + num.hours
       end

data/lib/tabs/resolutions/minute.rb

@@ -1,11 +1,15 @@
 module Tabs
   module Resolutions
     module Minute
-      extend Tabs::Resolutionable
+      include Tabs::Resolutionable
       extend self
 
       PATTERN = "%Y-%m-%d-%H-%M"
 
+      def name
+        :minute
+      end
+
       def serialize(timestamp)
         timestamp.strftime(PATTERN)
       end
@@ -19,6 +23,10 @@ module Tabs
         s / 1.minute
       end
 
+      def to_seconds
+        1.minute
+      end
+
       def add(ts, num)
         ts + num.minutes
       end

data/lib/tabs/resolutions/month.rb

@@ -1,11 +1,15 @@
 module Tabs
   module Resolutions
     module Month
-      extend Tabs::Resolutionable
+      include Tabs::Resolutionable
       extend self
 
       PATTERN = "%Y-%m"
 
+      def name
+        :month
+      end
+
       def serialize(timestamp)
         timestamp.strftime(PATTERN)
       end
@@ -19,6 +23,10 @@ module Tabs
         s / 1.month
       end
 
+      def to_seconds
+        1.month
+      end
+
       def add(ts, num)
         ts + num.months
       end

data/lib/tabs/resolutions/week.rb

@@ -1,26 +1,32 @@
 module Tabs
   module Resolutions
     module Week
-      extend Tabs::Resolutionable
+      include Tabs::Resolutionable
       extend self
 
-      PATTERN = "%Y-%W"
+      PATTERN = "%Y-%m-%d"
+
+      def name
+        :week
+      end
 
       def serialize(timestamp)
-        timestamp.strftime(PATTERN)
+        normalize(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)
+        dt = DateTime.strptime(str, PATTERN)
         self.normalize(dt)
       end
 
-      def seconds(s)
+      def from_seconds(s)
         s / 1.week
       end
 
+      def to_seconds
+        1.week
+      end
+
       def add(ts, num)
         ts + num.weeks
       end

data/lib/tabs/resolutions/year.rb

@@ -1,11 +1,15 @@
 module Tabs
   module Resolutions
     module Year
-      extend Tabs::Resolutionable
+      include Tabs::Resolutionable
       extend self
 
       PATTERN = "%Y"
 
+      def name
+        :year
+      end
+
       def serialize(timestamp)
         timestamp.strftime(PATTERN)
       end
@@ -19,6 +23,10 @@ module Tabs
         s / 1.year
       end
 
+      def to_seconds
+        1.year
+      end
+
       def add(ts, num)
         ts + num.years
       end

data/lib/tabs/storage.rb

@@ -6,77 +6,99 @@ module Tabs
       @redis ||= Config.redis
     end
 
+    def tabs_key(key)
+      if Tabs::Config.prefix.blank?
+        "tabs:#{key}"
+      else
+        "tabs:#{Tabs::Config.prefix}:#{key}"
+      end
+    end
+
     def exists(key)
-      redis.get("tabs:#{key}")
+      redis.exists(tabs_key(key))
+    end
+
+    def expireat(key, unix_timestamp)
+      redis.expireat(tabs_key(key), unix_timestamp)
+    end
+
+    def ttl(key)
+      redis.ttl(tabs_key(key))
     end
 
     def get(key)
-      redis.get("tabs:#{key}")
+      redis.get(tabs_key(key))
     end
 
     def mget(*keys)
-      prefixed_keys = keys.map { |k| "tabs:#{k}" }
+      prefixed_keys = keys.map { |k| tabs_key(k) }
       redis.mget(*prefixed_keys)
     end
 
     def set(key, value)
-      redis.set("tabs:#{key}", value)
+      redis.set(tabs_key(key), value)
     end
 
     def del(*keys)
       return 0 if keys.empty?
-      prefixed_keys = keys.map { |k| "tabs:#{k}" }
+      prefixed_keys = keys.map { |k| tabs_key(k) }
       redis.del(*prefixed_keys)
     end
 
     def del_by_prefix(pattern)
-      keys = redis.keys("tabs:#{pattern}*")
+      keys = redis.keys("#{tabs_key(pattern)}*")
       return 0 if keys.empty?
       redis.del(*keys)
     end
 
     def incr(key)
-      redis.incr("tabs:#{key}")
+      redis.incr(tabs_key(key))
     end
 
     def rpush(key, value)
-      redis.rpush("tabs:#{key}", value)
+      redis.rpush(tabs_key(key), value)
     end
 
     def sadd(key, *values)
-      redis.sadd("tabs:#{key}", *values)
+      redis.sadd(tabs_key(key), *values)
     end
 
     def smembers(key)
-      redis.smembers("tabs:#{key}")
+      redis.smembers(tabs_key(key))
+    end
+
+    def smembers_all(*keys)
+      redis.pipelined do
+        keys.map{ |key| smembers(key)}
+      end
     end
 
     def sismember(key, value)
-      redis.sismember("tabs:#{key}", value)
+      redis.sismember(tabs_key(key), value)
     end
 
     def hget(key, field)
-      redis.hget("tabs:#{key}", field)
+      redis.hget(tabs_key(key), field)
     end
 
     def hset(key, field, value)
-      redis.hset("tabs:#{key}", field, value)
+      redis.hset(tabs_key(key), field, value)
     end
 
     def hdel(key, field)
-      redis.hdel("tabs:#{key}", field)
+      redis.hdel(tabs_key(key), field)
     end
 
     def hkeys(key)
-      redis.hkeys("tabs:#{key}")
+      redis.hkeys(tabs_key(key))
     end
 
     def hincrby(key, field, value)
-      redis.hincrby("tabs:#{key}", field, value)
+      redis.hincrby(tabs_key(key), field, value)
     end
 
     def hgetall(key)
-      redis.hgetall("tabs:#{key}")
+      redis.hgetall(tabs_key(key))
     end
 
   end

data/lib/tabs/tabs.rb

@@ -2,10 +2,11 @@ module Tabs
   extend self
   extend Tabs::Storage
 
-  class UnknownTypeError < Exception; end
-  class DuplicateMetricError < Exception; end
-  class UnknownMetricError < Exception; end
-  class MetricTypeMismatchError < Exception; end
+  class UnknownTypeError < StandardError; end
+  class DuplicateMetricError < StandardError; end
+  class UnknownMetricError < StandardError; end
+  class MetricTypeMismatchError < StandardError; end
+  class ResolutionMissingError < StandardError; end
 
   METRIC_TYPES = ["counter", "value", "task"]
 
@@ -94,6 +95,13 @@ module Tabs
     metrics.each { |key| self.drop_metric! key }
   end
 
+  def drop_resolution_for_metric!(key, resolution)
+    raise UnknownMetricError.new("Unknown metric: #{key}") unless metric_exists?(key)
+    raise ResolutionMissingError.new(resolution) unless Tabs::Resolution.all.include? resolution
+    metric = get_metric(key)
+    metric.drop_by_resolution!(resolution) unless metric_type(key) == "task"
+  end
+
   private
 
   def metric_klass(type)

data/lib/tabs/version.rb

@@ -1,3 +1,3 @@
 module Tabs
-  VERSION = "0.9.1"
+  VERSION = "1.0.0"
 end