pulse_meter_core 0.4.13

data/lib/pulse_meter/sensor/timelined/average.rb

@@ -0,0 +1,32 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Average value over interval
+      class Average < Timeline
+
+        def aggregate_event(key, value)
+          command_aggregator.hincrby(key, :count, 1)
+          command_aggregator.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
+
+        private
+
+        def deflate(value)
+          value.to_f
+        end
+
+      end
+    end
+  end
+end
+

data/lib/pulse_meter/sensor/timelined/counter.rb

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

data/lib/pulse_meter/sensor/timelined/hashed_counter.rb

@@ -0,0 +1,31 @@
+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 do |k, v|
+            command_aggregator.hincrby(key, k, v)
+            command_aggregator.hincrby(key, :total, v)
+          end
+        end
+
+        def summarize(key)
+          redis.
+            hgetall(key).
+            inject({}) {|h, (k, v)| h[k] = v.to_i; h}.
+            to_json
+        end
+
+        private
+
+        def deflate(value)
+          JSON.parse(value)
+        end
+      end
+    end
+  end
+end

data/lib/pulse_meter/sensor/timelined/hashed_indicator.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Saves last registered values for multiple flags per interval.
+      # Good replacement for multiple indicators to be visualized together
+      class HashedIndicator < Timeline
+        def aggregate_event(key, data)
+          data.each_pair do |k, v|
+            command_aggregator.hset(key, k, v) if v.respond_to?(:to_f)
+          end
+        end
+
+        def summarize(key)
+          redis.
+            hgetall(key).
+            inject({}) {|h, (k, v)| h[k] = v.to_f; h}.
+            to_json
+        end
+
+        private
+
+        def deflate(value)
+          JSON.parse(value)
+        end
+      end
+    end
+  end
+end

data/lib/pulse_meter/sensor/timelined/indicator.rb

@@ -0,0 +1,23 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Saves last registered flag float value for each interval
+      class Indicator < Timeline
+        def aggregate_event(key, value)
+          command_aggregator.set(key, value.to_f)
+        end
+
+        def summarize(key)
+          redis.get(key)
+        end
+
+        private
+
+        def deflate(value)
+          value.to_f
+        end
+
+      end
+    end
+  end
+end

data/lib/pulse_meter/sensor/timelined/max.rb

@@ -0,0 +1,19 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Calculates max value in interval
+      class Max < ZSetBased
+
+        def update(key)
+          command_aggregator.zremrangebyrank(key, 0, -2)
+        end
+
+        def calculate(key, _)
+          max_el = redis.zrange(key, -1, -1)[0]
+          redis.zscore(key, max_el)
+        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,19 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Calculates min value in interval
+      class Min < ZSetBased
+
+        def update(key)
+          command_aggregator.zremrangebyrank(key, 1, -1)
+        end
+
+        def calculate(key, _)
+          min_el = redis.zrange(key, 0, 0)[0]
+          redis.zscore(key, min_el)
+        end
+
+      end
+    end
+  end
+end

data/lib/pulse_meter/sensor/timelined/multi_percentile.rb

@@ -0,0 +1,34 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Calculates n'th percentile in interval
+      class MultiPercentile < ZSetBased
+        attr_reader :p_value
+
+        def initialize(name, options)
+          @p_value = assert_array!(options, :p, [])
+          @p_value.each {|p| assert_ranged_float!({:percentile => p}, :percentile, 0, 1)}
+          super(name, options)
+        end
+
+        def calculate(key, count)
+          count = 
+          @p_value.each_with_object({}) { |p, acc|
+            position = p > 0 ? (p * count).round - 1 : 0
+            el = redis.zrange(key, position, position)[0]
+            acc[p] = redis.zscore(key, el)
+          }.to_json
+        end
+
+        private
+        
+        def deflate(value)
+          hash = JSON.parse(value)
+          hash.each {|p, v| hash[p] = v.to_f}
+          hash
+        end
+
+      end
+    end
+  end
+end

data/lib/pulse_meter/sensor/timelined/percentile.rb

@@ -0,0 +1,22 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Calculates n'th percentile in interval
+      class Percentile < ZSetBased
+        attr_reader :p_value
+
+        def initialize(name, options)
+          @p_value = assert_ranged_float!(options, :p, 0, 1)
+          super(name, options)
+        end
+
+        def calculate(key, count)
+          position = @p_value > 0 ? (@p_value * count).round - 1 : 0
+          el = redis.zrange(key, position, position)[0]
+          redis.zscore(key, el)
+        end
+
+      end
+    end
+  end
+end

data/lib/pulse_meter/sensor/timelined/uniq_counter.rb

@@ -0,0 +1,22 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Counts unique events per interval
+      class UniqCounter < Timeline
+        def aggregate_event(key, value)
+          command_aggregator.sadd(key, value)
+        end
+
+        def summarize(key)
+          redis.scard(key)
+        end
+
+        private
+        
+        def deflate(value)
+          value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/pulse_meter/sensor/timelined/zset_based.rb

@@ -0,0 +1,37 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      class ZSetBased < Timeline
+
+        def update(_)
+        end
+
+        def calculate(key)
+          0
+        end
+
+        def aggregate_event(key, value)
+          command_aggregator.zadd(key, value, "#{value}::#{uniqid}")
+          update(key)
+        end
+
+        def summarize(key)
+          count = redis.zcard(key)
+          if count > 0
+            calculate(key, count)
+          else
+            nil
+          end
+        end
+
+        private
+
+        def deflate(value)
+          value.to_f
+        end
+
+      end
+    end
+  end
+end
+

data/lib/pulse_meter/sensor/uniq_counter.rb

@@ -0,0 +1,24 @@
+require 'json'
+
+# Static counter to count unique values
+module PulseMeter
+  module Sensor
+    class UniqCounter < Counter
+
+      # Returs number of unique values ever sent to counter
+      # @return [Fixnum]
+      def value
+        redis.scard(value_key)
+      end
+
+      private
+
+      # Processes event
+      # @param name [String] value to be counted
+      def process_event(name)
+        command_aggregator.sadd(value_key, name)
+      end
+
+    end
+  end
+end

data/lib/pulse_meter/udp_server.rb

@@ -0,0 +1,45 @@
+require 'socket'
+require 'timeout'
+
+module PulseMeter
+  class UDPServer
+    MAX_PACKET = 1024
+  
+    def initialize(host, port)
+      @socket = UDPSocket.new
+      @socket.do_not_reverse_lookup = true
+      @socket.bind(host, port)
+    end
+
+    def start(max_packets = nil)
+      while true do
+        if max_packets
+          break if max_packets <= 0
+          max_packets -= 1
+        end
+        process_packet
+      end
+    end
+
+    private
+
+    def process_packet
+      raw_data, _ = @socket.recvfrom(MAX_PACKET)
+      data = parse_data(raw_data)
+      PulseMeter.redis.multi do
+        data.each do |command|
+          PulseMeter.redis.send(*command)
+        end
+      end
+    rescue StandardError => e
+      PulseMeter.error "Error processing packet: #{e}"
+    end
+
+    def parse_data(data)
+      JSON.parse(data)
+    rescue
+      PulseMeter.error "Bad redis data: #{data.inspect}"
+      []
+    end
+  end
+end

data/lib/pulse_meter_core.rb

@@ -0,0 +1,66 @@
+require "redis"
+require "logger"
+require "pulse_meter/mixins/dumper"
+require "pulse_meter/mixins/utils"
+require "pulse_meter/observer"
+require "pulse_meter/observer/extended"
+require "pulse_meter/sensor"
+require "pulse_meter/sensor/configuration"
+
+require "pulse_meter/command_aggregator/async"
+require "pulse_meter/command_aggregator/sync"
+require "pulse_meter/command_aggregator/udp"
+
+require "pulse_meter/udp_server"
+
+module PulseMeter
+  @@redis = nil
+
+  # Returns global Redis client
+  def self.redis
+    @@redis 
+  end
+
+  # Sets global Redis client
+  # @param redis [Redis] redis client
+  def self.redis=(redis)
+    @@redis = redis
+  end
+
+  # Returns global command aggegator (i.e. object that accumulates Redis commands emitted by events and sends them into client)
+  def self.command_aggregator
+    @@command_aggregator ||= PulseMeter::CommandAggregator::Async.instance
+  end
+  
+  # Sets global command_aggregator
+  # @param type [Symbol] type of command aggegator (:async or :sync)
+  # @raise [ArgumentError] if type is none of :async, :sync
+  def self.command_aggregator=(command_aggregator)
+    @@command_aggregator = case command_aggregator
+      when :sync; PulseMeter::CommandAggregator::Sync.instance
+      when :async; PulseMeter::CommandAggregator::Async.instance
+      else command_aggregator
+    end
+  end
+
+  # Sets global logger for all PulseMeter error messages
+  # @param logger [Logger] logger to be used
+  def self.logger=(new_logger)
+    @@logger = new_logger
+  end
+
+  # Returns global PulseMeter logger
+  def self.logger
+    @@logger ||= begin 
+      logger = Logger.new($stderr)
+      logger.datetime_format = '%Y-%m-%d %H:%M:%S.%3N'
+      logger
+    end
+  end
+
+  # Sends error message to PulseMeter logger
+  # @param message [String] error message
+  def self.error(msg)
+    logger.error(msg)
+  end
+end