pulse-meter 0.4.9 → 0.4.11

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

@@ -1,32 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,38 +0,0 @@
-module PulseMeter
-  module Sensor
-    module Timelined
-      # Calculates min value in interval
-      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

@@ -1,24 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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/version.rb

@@ -1,3 +0,0 @@
-module PulseMeter
-  VERSION = "0.4.9"
-end

data/lib/pulse-meter/visualize/app.rb

@@ -1,78 +0,0 @@
-require 'gon-sinatra'
-require 'haml'
-require 'sinatra/base'
-require 'sinatra/partial'
-
-module PulseMeter
-  module Visualize
-    class App < Sinatra::Base
-      include PulseMeter::Mixins::Utils
-      register Gon::Sinatra
-      register Sinatra::Partial
-
-      set :partial_template_engine, :haml
-
-      def initialize(layout)
-        @layout = layout
-        super()
-      end
-
-      configure :production, :development do
-        enable :logging
-      end
-
-      get '/' do
-        @title = @layout.title
-        gon.pageInfos = camelize_keys(@layout.page_infos)
-        gon.options = camelize_keys(@layout.options)
-        haml :main
-      end
-
-      get '/pages/:id/widgets' do
-        id = params[:id].to_i 
-
-        content_type :json
-        camelize_keys(@layout.widgets(id - 1)).to_json
-      end
-
-      get '/pages/:page_id/widgets/:id' do
-        page_id = params[:page_id].to_i 
-        id = params[:id].to_i
-        timespan = params[:timespan].to_i
-				start_time = params[:startTime].to_i
-				end_time = params[:endTime].to_i
-
-        content_type :json
-        camelize_keys(
-					@layout.widget(
-						page_id - 1,
-						id - 1,
-						timespan: timespan,
-						start_time: start_time,
-						end_time: end_time
-					)
-				).to_json
-      end
-
-      get '/sensors' do
-        content_type :json
-        camelize_keys(@layout.sensor_list).to_json
-      end
-
-      get '/dynamic_widget' do
-				start_time = params[:startTime].to_i
-				end_time = params[:endTime].to_i
-        timespan = params[:timespan].to_i
-
-        content_type :json
-        camelize_keys(@layout.dynamic_widget(
-          timespan: timespan,
-          start_time: start_time,
-          end_time: end_time,
-          sensors: params[:sensor],
-          type: params[:type])
-        ).to_json
-      end
-    end
-  end
-end