tabstabs 2.0.0

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/tabs_tabs.rb

@@ -0,0 +1,26 @@
+require "active_support/all"
+require "redis"
+require "json/ext"
+
+require "tabs_tabs/version"
+require "tabs_tabs/config"
+require "tabs_tabs/storage"
+require "tabs_tabs/helpers"
+
+require "tabs_tabs/resolutionable"
+require "tabs_tabs/resolutions/minute"
+require "tabs_tabs/resolutions/hour"
+require "tabs_tabs/resolutions/day"
+require "tabs_tabs/resolutions/week"
+require "tabs_tabs/resolutions/month"
+require "tabs_tabs/resolutions/year"
+require "tabs_tabs/resolution"
+
+require "tabs_tabs/metrics/counter/stats"
+require "tabs_tabs/metrics/counter"
+require "tabs_tabs/metrics/value/stats"
+require "tabs_tabs/metrics/value"
+require "tabs_tabs/metrics/task/token"
+require "tabs_tabs/metrics/task"
+
+require "tabs_tabs/tabs_tabs"

data/lib/tabs_tabs/config.rb

@@ -0,0 +1,65 @@
+module TabsTabs
+  module Config
+    extend self
+
+    def decimal_precision
+      @decimal_precision ||= 5
+    end
+
+    def decimal_precision=(precision)
+      @decimal_precision = precision
+    end
+
+    def redis=(arg)
+      if arg.is_a?(Redis)
+        @redis = arg
+      else
+        @redis = Redis.new(arg)
+      end
+    end
+
+    def redis
+      @redis ||= Redis.new
+    end
+
+    def prefix=(arg)
+      @prefix = arg
+    end
+
+    def prefix
+      @prefix
+    end
+
+    def register_resolution(klass)
+      TabsTabs::Resolution.register(klass)
+    end
+
+    def unregister_resolutions(*resolutions)
+      TabsTabs::Resolution.unregister(resolutions)
+    end
+
+    def expiration_settings
+      @expiration_settings ||= {}
+    end
+
+    def set_expirations(resolution_hash)
+      resolution_hash.each do |resolution, expires_in_seconds|
+        raise TabsTabs::ResolutionMissingError.new(resolution) unless TabsTabs::Resolution.all.include? resolution
+        expiration_settings[resolution] = expires_in_seconds
+      end
+    end
+
+    def expires?(resolution)
+      expiration_settings.has_key?(resolution)
+    end
+
+    def expires_in(resolution)
+      expiration_settings[resolution]
+    end
+
+    def reset_expirations
+      @expiration_settings = {}
+    end
+
+  end
+end

data/lib/tabs_tabs/helpers.rb

@@ -0,0 +1,27 @@
+module TabsTabs
+  module Helpers
+    extend self
+
+    def timestamp_range(period, resolution)
+      period = normalize_period(period, resolution)
+      dt = period.first
+      [].tap do |arr|
+        arr << dt
+        while (dt = TabsTabs::Resolution.add(resolution, dt, 1)) <= period.last
+          arr << dt.utc
+        end
+      end
+    end
+
+    def normalize_period(period, resolution)
+      period_start = TabsTabs::Resolution.normalize(resolution, period.first.utc)
+      period_end = TabsTabs::Resolution.normalize(resolution, period.last.utc)
+      (period_start..period_end)
+    end
+
+    def to_numeric(v)
+      ((float = Float(v)) && (float % 1.0 == 0) ? float.to_i : float) rescue v
+    end
+
+  end
+end

data/lib/tabs_tabs/metrics/counter.rb

@@ -0,0 +1,69 @@
+module TabsTabs
+  module Metrics
+    class Counter
+      include Storage
+      include Helpers
+
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+      end
+
+      def increment(timestamp=Time.now)
+        timestamp.utc
+        TabsTabs::Resolution.all.each do |resolution|
+          increment_resolution(resolution, timestamp)
+        end
+        increment_total
+        true
+      end
+
+      def stats(period, resolution)
+        timestamps = timestamp_range period, resolution
+        keys = timestamps.map do |timestamp|
+          storage_key(resolution, timestamp)
+        end
+
+        values = mget(*keys).map do |v|
+          {
+            "timestamp" => timestamps.shift,
+            "count" => (v || 0).to_i
+          }.with_indifferent_access
+        end
+
+        Stats.new(period, resolution, values)
+      end
+
+      def total
+        (get("stat:counter:#{key}:total") || 0).to_i
+      end
+
+      def drop!
+        del_by_prefix("stat:counter:#{key}")
+      end
+
+      def drop_by_resolution!(resolution)
+        del_by_prefix("stat:counter:#{key}:count:#{resolution}")
+      end
+
+      def storage_key(resolution, timestamp)
+        formatted_time = TabsTabs::Resolution.serialize(resolution, timestamp)
+        "stat:counter:#{key}:count:#{resolution}:#{formatted_time}"
+      end
+
+      private
+
+      def increment_resolution(resolution, timestamp)
+        store_key = storage_key(resolution, timestamp)
+        incr(store_key)
+        TabsTabs::Resolution.expire(resolution, store_key, timestamp)
+      end
+
+      def increment_total
+        incr("stat:counter:#{key}:total")
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module TabsTabs
+  module Metrics
+    class Counter
+      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 total
+          @total ||= values.map { |v| v["count"] }.sum
+        end
+
+        def min
+          @min ||= values.min_by { |v| v["count"] }["count"]
+        end
+
+        def max
+          @max ||= values.max_by { |v| v["count"] }["count"]
+        end
+
+        def avg
+          return 0 if values.size.zero?
+          (self.total.to_f / values.size.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/metrics/task.rb

@@ -0,0 +1,72 @@
+module TabsTabs
+  module Metrics
+    class Task
+      include TabsTabs::Storage
+      include TabsTabs::Helpers
+
+      class UnstartedTaskMetricError < Exception; end
+
+      Stats = Struct.new(
+        :started_within_period,
+        :completed_within_period,
+        :started_and_completed_within_period,
+        :completion_rate,
+        :average_completion_time
+      )
+
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+      end
+
+      def start(token, timestamp=Time.now)
+        Token.new(token, key).start(timestamp)
+        true
+      end
+
+      def complete(token, timestamp=Time.now)
+        Token.new(token, key).complete(timestamp)
+        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.select { |token| completed_tokens.include? token }
+        completion_rate = (matching_tokens.size.to_f / range.size).round(Config.decimal_precision)
+        elapsed_times = matching_tokens.map { |t| t.time_elapsed(resolution) }
+        average_completion_time = matching_tokens.blank? ? 0.0 : (elapsed_times.sum) / matching_tokens.size
+        Stats.new(
+          started_tokens.size,
+          completed_tokens.size,
+          matching_tokens.size,
+          completion_rate,
+          average_completion_time
+        )
+      end
+
+      def drop!
+        del_by_prefix("stat:task:#{key}")
+      end
+
+      def storage_key(resolution, timestamp, type)
+        formatted_time = TabsTabs::Resolution.serialize(resolution, timestamp)
+        "stat:task:#{key}:#{type}:#{resolution}:#{formatted_time}"
+      end
+
+      private
+
+      def tokens_for_period(range, resolution, type)
+        keys = keys_for_range(range, resolution, type)
+        smembers_all(*keys).compact.map(&:to_a).flatten.map { |t| Token.new(t, key) }
+      end
+
+      def keys_for_range(range, resolution, type)
+        range.map { |timestamp| storage_key(resolution, timestamp, type) }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module TabsTabs
+  module Metrics
+    class Task
+      class Token
+        include Storage
+
+        attr_reader :key
+        attr_reader :token
+
+        def initialize(token, key)
+          @key = key
+          @token = token
+        end
+
+        def start(timestamp=Time.now)
+          self.start_time = timestamp.utc
+          sadd(tokens_storage_key, token)
+          TabsTabs::Resolution.all.each { |res| record_start(res, start_time) }
+        end
+
+        def complete(timestamp=Time.now)
+          self.complete_time = timestamp.utc
+          unless sismember(tokens_storage_key, token)
+            raise UnstartedTaskMetricError.new("No task for metric '#{key}' was started with token '#{token}'")
+          end
+          TabsTabs::Resolution.all.each { |res| record_complete(res, complete_time) }
+        end
+
+        def time_elapsed(resolution)
+          TabsTabs::Resolution.from_seconds(resolution, complete_time - start_time)
+        end
+
+        def ==(other_token)
+          self.token == other_token.token
+        end
+
+        def to_s
+          "#{super}:#{token}"
+        end
+
+        private
+
+        def storage_key(resolution, timestamp, type)
+          formatted_time = TabsTabs::Resolution.serialize(resolution, timestamp)
+          "stat:task:#{key}:#{type}:#{resolution}:#{formatted_time}"
+        end
+
+        def started_storage_key
+          "stat:task:#{key}:#{token}:started_time"
+        end
+
+        def completed_storage_key
+          "stat:task:#{key}:#{token}:completed_time"
+        end
+
+        def tokens_storage_key
+          "stat:task:#{key}:tokens"
+        end
+
+        def record_start(resolution, timestamp)
+          sadd(storage_key(resolution, timestamp, "started"), token)
+        end
+
+        def record_complete(resolution, timestamp)
+          sadd(storage_key(resolution, timestamp, "completed"), token)
+        end
+
+        def start_time=(timestamp)
+          set(started_storage_key, timestamp)
+          @start_time = timestamp
+        end
+
+        def start_time
+          Time.parse(get(started_storage_key))
+        end
+
+        def complete_time=(timestamp)
+          set(completed_storage_key, timestamp)
+          @complete_time = timestamp
+        end
+
+        def complete_time
+          Time.parse(get(completed_storage_key))
+        end
+
+      end
+    end
+  end
+end

data/lib/tabs_tabs/metrics/value.rb

@@ -0,0 +1,91 @@
+module TabsTabs
+  module Metrics
+    class Value
+      include Storage
+      include Helpers
+
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+      end
+
+      def record(value, timestamp=Time.now)
+        timestamp.utc
+        TabsTabs::Resolution.all.each do |resolution|
+          store_key = storage_key(resolution, timestamp)
+          update_values(store_key, value)
+          TabsTabs::Resolution.expire(resolution, store_key, timestamp)
+        end
+        true
+      end
+
+      def stats(period, resolution)
+        timestamps = timestamp_range period, resolution
+        keys = timestamps.map do |timestamp|
+          storage_key(resolution, timestamp)
+        end
+
+        values = mget(*keys).map do |v|
+          value = v.nil? ? default_value(0) : JSON.parse(v)
+          value["timestamp"] = timestamps.shift
+          value.with_indifferent_access
+        end
+
+        Stats.new(period, resolution, values)
+      end
+
+      def drop!
+        del_by_prefix("stat:value:#{key}")
+      end
+
+      def drop_by_resolution!(resolution)
+        del_by_prefix("stat:value:#{key}:data:#{resolution}")
+      end
+
+      def storage_key(resolution, timestamp)
+        formatted_time = TabsTabs::Resolution.serialize(resolution, timestamp)
+        "stat:value:#{key}:data:#{resolution}:#{formatted_time}"
+      end
+
+      private
+
+      def update_values(stat_key, value)
+        hash = get_current_hash(stat_key)
+        increment(hash, value)
+        update_min(hash, value)
+        update_max(hash, value)
+        update_avg(hash)
+        set(stat_key, JSON.generate(hash))
+      end
+
+      def get_current_hash(stat_key)
+        hash = get(stat_key)
+        return JSON.parse(hash) if hash
+        default_value
+      end
+
+      def increment(hash, value)
+        hash["count"] += 1
+        hash["sum"] += value.to_f
+      end
+
+      def update_min(hash, value)
+        hash["min"] = value.to_f if hash["min"].nil? || value.to_f < hash["min"]
+      end
+
+      def update_max(hash, value)
+        hash["max"] = value.to_f if hash["max"].nil? || value.to_f > hash["max"]
+      end
+
+      def update_avg(hash)
+        hash["avg"] = hash["sum"].to_f / hash["count"]
+      end
+
+      def default_value(nil_value=nil)
+        { "count" => 0, "min" => nil_value, "max" => nil_value, "sum" => 0.0, "avg" => 0.0 }
+      end
+
+    end
+  end
+end