pulse-meter-client-backport 0.1.0

data/lib/pulse-meter/sensor.rb

@@ -0,0 +1,44 @@
+require 'pulse-meter/sensor/base'
+require 'pulse-meter/sensor/counter'
+require 'pulse-meter/sensor/hashed_counter'
+require 'pulse-meter/sensor/indicator'
+require 'pulse-meter/sensor/timeline'
+require 'pulse-meter/sensor/timelined/average'
+require 'pulse-meter/sensor/timelined/counter'
+require 'pulse-meter/sensor/timelined/hashed_counter'
+require 'pulse-meter/sensor/timelined/min'
+require 'pulse-meter/sensor/timelined/max'
+require 'pulse-meter/sensor/timelined/percentile'
+require 'pulse-meter/sensor/timelined/median'
+
+# Top level sensor module
+module PulseMeter
+
+  # Atomic sensor data
+  SensorData = Struct.new(:start_time, :value)
+
+  # General sensor exception
+  class SensorError < StandardError; end
+
+  # Exception to be raised when sensor name is malformed
+  class BadSensorName < SensorError
+    def initialize(name, options = {})
+      super("Bad sensor name: `#{name}', only a-z letters and _ are allowed")
+    end
+  end
+
+  # Exception to be raised when Redis is not initialized
+  class RedisNotInitialized < SensorError
+    def initialize
+      super("PulseMeter.redis is not set")
+    end
+  end
+
+  # Exception to be raised when sensor cannot be dumped
+  class DumpError < SensorError; end
+
+  # Exception to be raised when sensor cannot be restored
+  class RestoreError < SensorError; end
+
+end
+  

data/lib/pulse-meter/sensor/base.rb

@@ -0,0 +1,75 @@
+module PulseMeter
+  module Sensor
+    # @abstract Subclass and override {#event} to implement sensor 
+    class Base
+      include PulseMeter::Mixins::Dumper
+
+      # @!attribute [rw] redis
+      #   @return [Redis] 
+      attr_accessor :redis
+      # @!attribute [r] name
+      #   @return [String] sensor name
+      attr_reader :name
+
+      # Initializes sensor and dumps it to redis
+      # @param name [String] sensor name
+      # @option options [String] :annotation Sensor annotation
+      # @raise [BadSensorName] if sensor name is malformed
+      # @raise [RedisNotInitialized] unless Redis is initialized
+      def initialize(name, options={})
+        @name = name.to_s
+        if options[:annotation]
+          annotate(options[:annotation])
+        end
+        raise BadSensorName, @name unless @name =~ /\A\w+\z/
+        raise RedisNotInitialized unless PulseMeter.redis
+        dump!
+      end
+
+      # Returns Redis instance
+      def redis
+        PulseMeter.redis
+      end
+
+      # Saves annotation to Redis
+      # @param description [String] Sensor annotation
+      def annotate(description)
+        redis.set(desc_key, description)
+      end
+
+      # Retrieves annotation from Redis
+      # @return [String] Sensor annotation
+      def annotation
+        redis.get(desc_key)
+      end
+
+      # Cleans up all sensor metadata in Redis
+      def cleanup
+        redis.del(desc_key)
+        cleanup_dump
+      end
+  
+      # @abstract Processes event
+      # @param value [Object] value produced by some kind of event
+      def event(value)
+        # do nothing here
+      end
+
+      protected
+      
+      # Forms Redis key to store annotation
+      def desc_key
+        "pulse_meter:desc:#{name}"
+      end
+      
+      # For a block
+      # @yield Executes it within Redis multi
+      def multi
+        redis.multi 
+        yield
+        redis.exec
+      end
+
+    end
+  end
+end

data/lib/pulse-meter/sensor/counter.rb

@@ -0,0 +1,36 @@
+# Static counter
+module PulseMeter
+  module Sensor
+    class Counter < Base
+
+      # Cleans up all sensor metadata in Redis
+      def cleanup
+        redis.del(value_key)
+        super
+      end
+
+      # Increments counter value by 1
+      def incr
+        event(1)
+      end
+
+      # Processes event by incremnting counter by given value
+      # @param value [Fixnum] increment
+      def event(value)
+        redis.incrby(value_key, value.to_i)
+      end
+
+      # Gets counter value
+      # @return [Fixnum]
+      def value
+        redis.get(value_key).to_i
+      end
+      
+      # Gets redis key by which counter value is stored
+      # @return [String]
+      def value_key
+        @value_key ||= "pulse_meter:value:#{name}"
+      end
+    end
+  end
+end

data/lib/pulse-meter/sensor/hashed_counter.rb

@@ -0,0 +1,31 @@
+require 'json'
+
+# Static hashed counter to count values by multiple keys
+module PulseMeter
+  module Sensor
+    class HashedCounter < Counter
+
+      # Increments counter value by 1 for given key
+      # @param key [String] key to be incremented
+      def incr(key)
+        event({key => 1})
+      end
+
+      # Processes events for multiple keys
+      # @param data [Hash] hash where keys represent counter keys
+      #   and values are increments for their keys
+      def event(data)
+        data.each_pair {|k, v| redis.hincrby(value_key, k, v.to_i)}
+      end
+
+      # Returs data stored in counter
+      # @return [Hash]
+      def value
+        redis.
+          hgetall(value_key).
+          inject(Hash.new(0)) {|h, (k, v)| h[k] = v.to_i; h}
+      end
+
+    end
+  end
+end

data/lib/pulse-meter/sensor/indicator.rb

@@ -0,0 +1,33 @@
+module PulseMeter
+  module Sensor
+    # Static indicator. In fact is is just a named variable with float value
+    class Indicator < Base
+
+      # Cleans up all sensor metadata in Redis
+      def cleanup
+        redis.del(value_key)
+        super
+      end
+
+      # Sets indicator value
+      # @param value [Float] new indicator value
+      def event(value)
+        redis.set(value_key, value.to_f)
+      end
+
+      # Get indicator value
+      # @return [Fixnum] indicator value or zero unless it was initialized
+      def value
+        val = redis.get(value_key)
+        val.nil? ? 0 : val.to_f
+      end
+
+      # Gets redis key by which counter value is stored
+      # @return [String]
+      def value_key
+        @value_key ||= "pulse_meter:value:#{name}"
+      end
+
+    end
+  end
+end

data/lib/pulse-meter/sensor/timeline.rb

@@ -0,0 +1,180 @@
+require 'securerandom'
+
+module PulseMeter
+  module Sensor
+    # @abstract Represents timelined sensor: series of values,
+    #   one value for each consequent time interval.
+    class Timeline < Base
+      include PulseMeter::Mixins::Utils
+
+      # @!attribute [r] interval
+      #   @return [Fixnum] Rotation interval
+      # @!attribute [r] ttl
+      #   @return [Fixnum] How long summarized data will be stored before expiration
+      # @!attribute [r] raw_data_ttl
+      #   @return [Fixnum] How long unsummarized raw data will be stored before expiration
+      # @!attribute [r] reduce_delay
+      #   @return [Fixnum] Delay between end of interval and summarization
+      attr_reader :interval, :ttl, :raw_data_ttl, :reduce_delay
+
+      # Default values for some sensor parameters
+      DEFAULTS = {
+        :raw_data_ttl => 3600,
+        :reduce_delay => 60,
+      }
+      
+      # Initializes sensor with given name and parameters
+      # @param name [String] sensor name
+      # @option options [Fixnum] :interval Rotation interval
+      # @option options [Fixnum] :ttl How long summarized data will be stored before expiration
+      # @option options [Fixnum] :raw_data_ttl How long unsummarized raw data will be stored before expiration
+      # @option options [Fixnum] :reduce_delay Delay between end of interval and summarization
+      def initialize(name, options)
+        @interval = assert_positive_integer!(options, :interval)
+        @ttl = assert_positive_integer!(options, :ttl)
+        @raw_data_ttl = assert_positive_integer!(options, :raw_data_ttl, DEFAULTS[:raw_data_ttl])
+        @reduce_delay = assert_positive_integer!(options, :reduce_delay, DEFAULTS[:reduce_delay])
+        super
+      end
+
+      # Clean up all sensor metadata and data
+      def cleanup
+        keys = redis.keys(raw_data_key('*')) + redis.keys(data_key('*'))
+        multi do
+          keys.each{|key| redis.del(key)}
+        end
+        super
+      end
+
+      # Processes event
+      def event(value = nil)
+        multi do
+          current_key = current_raw_data_key
+          aggregate_event(current_key, value)
+          redis.expire(current_key, raw_data_ttl)
+        end
+      end
+
+      
+      # Reduces data in given interval. 
+      # @note Interval id is
+      #   just unixtime of its lower bound. Ruduction is a process
+      #   of 'compressing' all interval's raw data to a single value.
+      #   When reduction is done summarized data is saved to Redis
+      #   separately with expiration time taken from sensor configuration.
+      # @param interval_id [Fixnum] 
+      def reduce(interval_id)
+        interval_raw_data_key = raw_data_key(interval_id)
+        return unless redis.exists(interval_raw_data_key)
+        value = summarize(interval_raw_data_key)
+        interval_data_key = data_key(interval_id)
+        multi do
+          redis.del(interval_raw_data_key)
+          redis.set(interval_data_key, value)
+          redis.expire(interval_data_key, ttl)
+        end
+      end
+
+      # Reduces data in all raw interval
+      def reduce_all_raw
+        min_time = Time.now - reduce_delay - interval
+        redis.keys(raw_data_key('*')).each do |key|
+          interval_id = key.split(':').last
+          next if Time.at(interval_id.to_i) > min_time
+          reduce(interval_id)
+        end
+      end
+
+      def self.reduce_all_raw
+        list_objects.each do |sensor|
+          sensor.reduce_all_raw if sensor.respond_to? :reduce_all_raw
+        end
+      end
+
+      # Returts sensor data within some last seconds
+      # @param time_ago [Fixnum] interval length in seconds
+      # @return [Array<SensorData>]
+      # @raise ArgumentError if argumets are not valid time objects
+      def timeline(time_ago)
+        raise ArgumentError unless time_ago.respond_to?(:to_i) && time_ago.to_i > 0
+        now = Time.now
+        timeline_within(now - time_ago.to_i, now)
+      end
+
+      # Returts sensor data within given time
+      # @param from [Time] lower bound
+      # @param till [Time] upper bound
+      # @return [Array<SensorData>]
+      # @raise ArgumentError if argumets are not valid time objects
+      def timeline_within(from, till)
+        raise ArgumentError unless from.kind_of?(Time) && till.kind_of?(Time)
+        start_time, end_time = from.to_i, till.to_i
+        current_interval_id = get_interval_id(start_time) + interval
+        res = []
+        while current_interval_id < end_time
+          res << get_timeline_value(current_interval_id)
+          current_interval_id += interval
+        end
+        res
+      end
+
+      # Returns sensor data for given interval.
+      #   If the interval is not over yet makes its data in-memory summarization
+      #   and returns calculated value
+      # @param interval_id [Fixnum]
+      # @return [SensorData]
+      def get_timeline_value(interval_id)
+        interval_data_key = data_key(interval_id)
+        return SensorData.new(Time.at(interval_id), redis.get(interval_data_key)) if redis.exists(interval_data_key)
+        interval_raw_data_key = raw_data_key(interval_id)
+        return SensorData.new(Time.at(interval_id), summarize(interval_raw_data_key)) if redis.exists(interval_raw_data_key)
+        SensorData.new(Time.at(interval_id), nil)
+      end
+
+      # Returns Redis key by which raw data for current interval is stored
+      def current_raw_data_key
+        raw_data_key(current_interval_id)
+      end
+
+      # Returns Redis key by which raw data for given interval is stored
+      # @param id [Fixnum] interval id
+      def raw_data_key(id)
+        "pulse_meter:raw:#{name}:#{id}"
+      end
+
+      # Returns Redis key by which summarized data for given interval is stored
+      # @param id [Fixnum] interval id
+      def data_key(id)
+        "pulse_meter:data:#{name}:#{id}"
+      end
+
+      # Returns interval id where given time is
+      # @param time [Time]
+      def get_interval_id(time)
+        (time.to_i / interval) * interval
+      end
+
+      # Returns current interval id
+      # @return [Fixnum]
+      def current_interval_id
+        get_interval_id(Time.now)
+      end
+
+      # @abstract Registeres event for current interval identified by key
+      # @param key [Fixnum] interval id
+      # @param value [Object] value to be aggregated
+      def aggregate_event(key, value)
+        # simple
+        redis.set(key, value)
+      end
+
+      # @abstract Summarizes all event within interval to a single value
+      # @param key [Fixnum] interval_id 
+      def summarize(key)
+        # simple
+        redis.get(key)
+      end
+
+    end
+  end
+end

data/lib/pulse-meter/sensor/timelined/average.rb

@@ -0,0 +1,26 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Average value over interval
+      class Average < Timeline
+
+        def aggregate_event(key, value)
+          redis.hincrby(key, :count, 1)
+          redis.hincrby(key, :sum, value)
+        end
+
+        def summarize(key)
+          count = redis.hget(key, :count)
+          sum = redis.hget(key, :sum)
+          if count && !count.empty?
+            sum.to_f / count.to_f
+          else
+            0
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/pulse-meter/sensor/timelined/counter.rb

@@ -0,0 +1,16 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Counts events per interval
+      class Counter < Timeline
+        def aggregate_event(key, value)
+          redis.incrby(key, value.to_i)
+        end
+
+        def summarize(key)
+          redis.get(key).to_i
+        end
+      end
+    end
+  end
+end