tabstabs 2.0.0

data/lib/tabs_tabs/metrics/value/stats.rb

@@ -0,0 +1,55 @@
+module TabsTabs
+  module Metrics
+    class Value
+      class Stats
+
+        include Enumerable
+        include Helpers
+
+        attr_reader :period, :resolution, :values
+
+        def initialize(period, resolution, values)
+          @period, @resolution, @values = period, resolution, values
+        end
+
+        def first
+          values.first
+        end
+
+        def last
+          values.last
+        end
+
+        def count
+          @count ||= values.map { |v| v["count"] }.sum
+        end
+
+        def sum
+          @sum ||= values.map { |v| v["sum"] }.sum
+        end
+
+        def min
+          @min ||= values.min_by { |v| v["min"] }["min"]
+        end
+
+        def max
+          @max ||= values.max_by { |v| v["max"] }["max"]
+        end
+
+        def avg
+          return 0 if count.zero?
+          (self.sum.to_f / self.count.to_f).round(Config.decimal_precision)
+        end
+
+        def each(&block)
+          values.each(&block)
+        end
+
+        def to_a
+          values
+        end
+
+      end
+    end
+  end
+end

data/lib/tabs_tabs/resolution.rb

@@ -0,0 +1,65 @@
+module TabsTabs
+  module Resolution
+    include Resolutionable
+    extend self
+
+    def register(klass)
+      @@resolution_classes ||= {}
+      @@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)
+      resolution_klass(resolution).serialize(timestamp)
+    end
+
+    def deserialize(resolution, str)
+      resolution_klass(resolution).deserialize(str)
+    end
+
+    def from_seconds(resolution, s)
+      resolution_klass(resolution).from_seconds(s)
+    end
+
+    def add(resolution, ts, num)
+      resolution_klass(resolution).add(ts, num)
+    end
+
+    def normalize(resolution, timestamp)
+      resolution_klass(resolution).normalize(timestamp)
+    end
+
+    def all
+      @@resolution_classes.keys
+    end
+
+    def expire(resolution, key, timestamp)
+      resolution_klass(resolution).expire(key, timestamp)
+    end
+
+    def reset_default_resolutions
+      @@resolution_classes = {}
+      TabsTabs::Resolution.register(TabsTabs::Resolutions::Minute)
+      TabsTabs::Resolution.register(TabsTabs::Resolutions::Hour)
+      TabsTabs::Resolution.register(TabsTabs::Resolutions::Day)
+      TabsTabs::Resolution.register(TabsTabs::Resolutions::Week)
+      TabsTabs::Resolution.register(TabsTabs::Resolutions::Month)
+      TabsTabs::Resolution.register(TabsTabs::Resolutions::Year)
+    end
+
+    private
+
+    def resolution_klass(resolution)
+      klass = @@resolution_classes[resolution]
+      raise TabsTabs::ResolutionMissingError.new(resolution) unless klass
+      klass
+    end
+
+  end
+end
+
+TabsTabs::Resolution.reset_default_resolutions

data/lib/tabs_tabs/resolutionable.rb

@@ -0,0 +1,48 @@
+module TabsTabs
+  module Resolutionable
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      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
+
+    end
+
+    def expire(key, timestamp)
+      return unless TabsTabs::Config.expires?(name)
+      resolution_ends_at = timestamp.utc.to_i + to_seconds
+      expires_at = resolution_ends_at + TabsTabs::Config.expires_in(name)
+      Storage.expireat(key, expires_at)
+    end
+
+  end
+end

data/lib/tabs_tabs/resolutions/day.rb

@@ -0,0 +1,40 @@
+module TabsTabs
+  module Resolutions
+    module Day
+      include TabsTabs::Resolutionable
+      extend self
+
+      PATTERN = "%Y-%m-%d"
+
+      def name
+        :day
+      end
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def from_seconds(s)
+        s / 1.day
+      end
+
+      def to_seconds
+        1.day
+      end
+
+      def add(ts, num)
+        ts + num.days
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month, ts.day)
+      end
+
+    end
+  end
+end

data/lib/tabs_tabs/resolutions/hour.rb

@@ -0,0 +1,40 @@
+module TabsTabs
+  module Resolutions
+    module Hour
+      include TabsTabs::Resolutionable
+      extend self
+
+      PATTERN = "%Y-%m-%d-%H"
+
+      def name
+        :hour
+      end
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def from_seconds(s)
+        s / 1.hour
+      end
+
+      def to_seconds
+        1.hour
+      end
+
+      def add(ts, num)
+        ts + num.hours
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month, ts.day, ts.hour)
+      end
+
+    end
+  end
+end

data/lib/tabs_tabs/resolutions/minute.rb

@@ -0,0 +1,40 @@
+module TabsTabs
+  module Resolutions
+    module Minute
+      include TabsTabs::Resolutionable
+      extend self
+
+      PATTERN = "%Y-%m-%d-%H-%M"
+
+      def name
+        :minute
+      end
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def from_seconds(s)
+        s / 1.minute
+      end
+
+      def to_seconds
+        1.minute
+      end
+
+      def add(ts, num)
+        ts + num.minutes
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month, ts.day, ts.hour, ts.min)
+      end
+
+    end
+  end
+end

data/lib/tabs_tabs/resolutions/month.rb

@@ -0,0 +1,40 @@
+module TabsTabs
+  module Resolutions
+    module Month
+      include TabsTabs::Resolutionable
+      extend self
+
+      PATTERN = "%Y-%m"
+
+      def name
+        :month
+      end
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def from_seconds(s)
+        s / 1.month
+      end
+
+      def to_seconds
+        1.month
+      end
+
+      def add(ts, num)
+        ts + num.months
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month)
+      end
+
+    end
+  end
+end

data/lib/tabs_tabs/resolutions/week.rb

@@ -0,0 +1,40 @@
+module TabsTabs
+  module Resolutions
+    module Week
+      include TabsTabs::Resolutionable
+      extend self
+
+      PATTERN = "%Y-%m-%d"
+
+      def name
+        :week
+      end
+
+      def serialize(timestamp)
+        normalize(timestamp).strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def from_seconds(s)
+        s / 1.week
+      end
+
+      def to_seconds
+        1.week
+      end
+
+      def add(ts, num)
+        ts + num.weeks
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year, ts.month, ts.day).beginning_of_week
+      end
+
+    end
+  end
+end

data/lib/tabs_tabs/resolutions/year.rb

@@ -0,0 +1,40 @@
+module TabsTabs
+  module Resolutions
+    module Year
+      include TabsTabs::Resolutionable
+      extend self
+
+      PATTERN = "%Y"
+
+      def name
+        :year
+      end
+
+      def serialize(timestamp)
+        timestamp.strftime(PATTERN)
+      end
+
+      def deserialize(str)
+        dt = DateTime.strptime(str, PATTERN)
+        self.normalize(dt)
+      end
+
+      def from_seconds(s)
+        s / 1.year
+      end
+
+      def to_seconds
+        1.year
+      end
+
+      def add(ts, num)
+        ts + num.years
+      end
+
+      def normalize(ts)
+        Time.utc(ts.year)
+      end
+
+    end
+  end
+end

data/lib/tabs_tabs/storage.rb

@@ -0,0 +1,105 @@
+module TabsTabs
+  module Storage
+    extend self
+
+    def redis
+      @redis ||= Config.redis
+    end
+
+    def tabs_key(key)
+      if TabsTabs::Config.prefix.blank?
+        "tabstabs:#{key}"
+      else
+        "tabstabs:#{TabsTabs::Config.prefix}:#{key}"
+      end
+    end
+
+    def exists(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(key))
+    end
+
+    def mget(*keys)
+      prefixed_keys = keys.map { |k| tabs_key(k) }
+      redis.mget(*prefixed_keys)
+    end
+
+    def set(key, value)
+      redis.set(tabs_key(key), value)
+    end
+
+    def del(*keys)
+      return 0 if keys.empty?
+      prefixed_keys = keys.map { |k| tabs_key(k) }
+      redis.del(*prefixed_keys)
+    end
+
+    def del_by_prefix(pattern)
+      keys = redis.keys("#{tabs_key(pattern)}*")
+      return 0 if keys.empty?
+      redis.del(*keys)
+    end
+
+    def incr(key)
+      redis.incr(tabs_key(key))
+    end
+
+    def rpush(key, value)
+      redis.rpush(tabs_key(key), value)
+    end
+
+    def sadd(key, *values)
+      redis.sadd(tabs_key(key), *values)
+    end
+
+    def smembers(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(key), value)
+    end
+
+    def hget(key, field)
+      redis.hget(tabs_key(key), field)
+    end
+
+    def hset(key, field, value)
+      redis.hset(tabs_key(key), field, value)
+    end
+
+    def hdel(key, field)
+      redis.hdel(tabs_key(key), field)
+    end
+
+    def hkeys(key)
+      redis.hkeys(tabs_key(key))
+    end
+
+    def hincrby(key, field, value)
+      redis.hincrby(tabs_key(key), field, value)
+    end
+
+    def hgetall(key)
+      redis.hgetall(tabs_key(key))
+    end
+
+  end
+end