pulse-meter 0.0.1

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

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

@@ -0,0 +1,22 @@
+require 'json'
+
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Counts multiple types of events per interval.
+      # Good replacement for multiple counters to be visualized together
+      class HashedCounter < Timeline
+        def aggregate_event(key, data)
+          data.each_pair {|k, v| redis.hincrby(key, k, v)}
+        end
+
+        def summarize(key)
+          redis.
+            hgetall(key).
+            inject({}) {|h, (k, v)| h[k] = v.to_i; h}.
+            to_json
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Calculates max value in interval
+      class Max < Timeline
+
+        def aggregate_event(key, value)
+          redis.zadd(key, value, "#{value}::#{uniqid}")
+          redis.zremrangebyrank(key, 0, -2)
+        end
+
+        def summarize(key)
+          count = redis.zcard(key)
+          if count > 0
+            max_el = redis.zrange(key, -1, -1)[0]
+            redis.zscore(key, max_el).to_f
+          else
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Calculates median of iterval values
+      class Median < Percentile
+
+        def initialize(name, options)
+          super(name, options.merge({:p => 0.5}))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Calculates min value in interval
+      class Min < Timeline
+
+        def aggregate_event(key, value)
+          redis.zadd(key, value, "#{value}::#{uniqid}")
+          redis.zremrangebyrank(key, 1, -1)
+        end
+
+        def summarize(key)
+          count = redis.zcard(key)
+          if count > 0
+            min_el = redis.zrange(key, 0, 0)[0]
+            redis.zscore(key, min_el).to_f
+          else
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Calculates n'th percentile in interval
+      class Percentile < Timeline
+        attr_reader :p_value
+
+        def initialize(name, options)
+          @p_value = assert_ranged_float!(options, :p, 0, 1)
+          super(name, options)
+        end
+
+        def aggregate_event(key, value)
+          redis.zadd(key, value, "#{value}::#{uniqid}")
+        end
+
+        def summarize(key)
+          count = redis.zcard(key)
+          if count > 0
+            position = @p_value > 0 ? (@p_value * count).round - 1 : 0
+            el = redis.zrange(key, position, position)[0]
+            redis.zscore(key, el).to_f
+          else
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end