pulse-meter 0.4.1 → 0.4.2

data/README.md

@@ -1,4 +1,5 @@
 [![Build Status](https://secure.travis-ci.org/savonarola/pulse-meter.png)](http://travis-ci.org/savonarola/pulse-meter)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/savonarola/pulse-meter)
 
 # PulseMeter
 
@@ -68,6 +69,7 @@ The following timeline sensors are available:
   * Multifactor sensor
   * Median value
   * Percentile
+  * MultiPercentile
   * Unique counter
 
 There are several caveats with timeline sensors:

data/lib/cmd.rb

@@ -9,6 +9,10 @@ module Cmd
     include PulseMeter::Mixins::Utils
     include PulseMeter::Mixins::Cmd
     no_tasks do
+      def create_redis
+        Redis.new :host => options[:host], :port => options[:port], :db => options[:db]
+      end
+
       def self.common_options
         method_option :host, :default => '127.0.0.1', :desc => "Redis host"
         method_option :port, :default => 6379, :desc => "Redis port"
@@ -53,7 +57,10 @@ module Cmd
       if "json" == options[:format]
         value = JSON.parse(value)
       end
-      with_safe_restore_of(name) {|sensor| sensor.event(value)}
+      with_safe_restore_of(name) {|sensor|
+        sensor.event(value)
+      }
+      PulseMeter.command_aggregator.wait_for_pending_events
     end
 
     desc "timeline NAME SECONDS", "Get sensor's NAME timeline for last SECONDS"
@@ -142,13 +149,8 @@ module Cmd
     desc "drop NAME DATE_FROM(YYYYmmddHHMMSS) DATE_TO(YYYYmmddHHMMSS)", "Drop timeline data of a particular sensor"
     common_options
     def drop(name, from, to)
-      time_from, time_to = [from, to].map do |str|
-        str.match(/\A(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\z/) do |m|
-          Time.gm(*m.captures.map(&:to_i))
-        end
-      end
-      fail! "DATE_FROM is not a valid timestamp" unless time_from.is_a?(Time)
-      fail! "DATE_TO is not a valid timestamp" unless time_to.is_a?(Time)
+      time_from = parse_time(from)
+      time_to = parse_time(to)
       with_safe_restore_of(name) do |sensor|
         fail! "Sensor #{name} has no drop_within method" unless sensor.respond_to?(:drop_within)
         sensor.drop_within(time_from, time_to)

data/lib/pulse-meter/mixins/cmd.rb

@@ -5,7 +5,7 @@ module PulseMeter
     # Mixin with command-line utilities
     module Cmd
       def with_redis
-        PulseMeter.redis = Redis.new :host => options[:host], :port => options[:port], :db => options[:db]
+        PulseMeter.redis = create_redis
         yield
       end
 

data/lib/pulse-meter/mixins/utils.rb

@@ -88,6 +88,20 @@ module PulseMeter
         (first_letter_upper ? first.capitalize : first.downcase) + terms.map(&:capitalize).join
       end
 
+      # Converts string of the form YYYYmmddHHMMSS (considered as UTC) to Time
+      # @param str [String] string to be converted
+      # @return [Time]
+      # @raise [ArgumentError] unless passed value responds to to_s
+      def parse_time(str)
+        raise ArgumentError unless str.respond_to?(:to_s)
+        m = str.to_s.match(/\A(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\z/)
+        if m
+          Time.gm(*m.captures.map(&:to_i))
+        else
+          raise ArgumentError, "`#{str}' is not a YYYYmmddHHMMSS time"
+        end
+      end
+
       # Symbolizes hash keys
       def symbolize_keys(h)
         h.each_with_object({}) do |(k, v), acc|

data/lib/pulse-meter/observer.rb

@@ -8,13 +8,9 @@ module PulseMeter
       # @param method [Symbol] instance method name
       def unobserve_method(klass, method)
         with_observer = method_with_observer(method)
-        without_observer = method_without_observer(method)
-
-        return unless klass.method_defined? with_observer
-        klass.class_eval do
-          alias_method method, without_observer
-          remove_method with_observer
-          remove_method without_observer
+        if klass.method_defined?(with_observer)
+          block = unchain_block(method)
+          klass.class_eval &block
         end
       end
 
@@ -23,13 +19,10 @@ module PulseMeter
       # @param method [Symbol] class method name
       def unobserve_class_method(klass, method)
         with_observer = method_with_observer(method)
-        without_observer = method_without_observer(method)
-
-        return unless klass.respond_to? with_observer
-        metaclass(klass).instance_eval do
-          alias_method method, without_observer
-          remove_method with_observer
-          remove_method without_observer
+        if klass.respond_to?(with_observer)
+          method_owner = metaclass(klass)
+          block = unchain_block(method)
+          method_owner.instance_eval &block
         end
       end
 
@@ -40,27 +33,9 @@ module PulseMeter
       # @param proc [Proc] proc to be called in context of receiver each time observed method called
       def observe_method(klass, method, sensor, &proc)
         with_observer = method_with_observer(method)
-        without_observer = method_without_observer(method)
-
-        return if klass.method_defined? with_observer
-            
-        klass.class_eval do
-          alias_method without_observer, method
-          define_method with_observer do |*args, &block|
-            result = nil
-            start_time = Time.now
-            begin
-              result = self.send without_observer, *args, &block
-            ensure
-              begin
-                delta = ((Time.now - start_time) * 1000).to_i
-                sensor.instance_exec delta, *args, &proc
-              rescue Exception
-              end
-            end
-            result
-          end
-          alias_method method, with_observer
+        unless klass.method_defined?(with_observer)
+          block = chain_block(method, sensor, &proc)
+          klass.class_eval &block
         end
       end
 
@@ -71,31 +46,55 @@ module PulseMeter
       # @param proc [Proc] proc to be called in context of receiver each time observed method called
       def observe_class_method(klass, method, sensor, &proc)
         with_observer = method_with_observer(method)
-        without_observer = method_without_observer(method)
+        unless klass.respond_to?(with_observer)
+          method_owner = metaclass(klass)
+          block = chain_block(method, sensor, &proc)
+          method_owner.instance_eval &block
+        end
+      end
 
-        return if klass.respond_to? with_observer
+      private
+
+      def unchain_block(method)
+        with_observer = method_with_observer(method)
+        without_observer = method_without_observer(method)
 
-        metaclass(klass).instance_eval do
-          alias_method without_observer, method
-          define_method with_observer do |*args, &block|
-            result = nil
-            start_time = Time.now
+        Proc.new do
+          alias_method(method, without_observer)
+          remove_method(with_observer)
+          remove_method(without_observer)
+        end
+      end
+    
+      def define_instrumented_method(method_owner, method, receiver, &handler)
+        with_observer = method_with_observer(method)
+        without_observer = method_without_observer(method)
+        method_owner.send(:define_method, with_observer) do |*args, &block|
+          start_time = Time.now
+          begin
+            self.send(without_observer, *args, &block)
+          ensure
             begin
-              result = self.send without_observer, *args, &block
-            ensure
-              begin
-                delta = ((Time.now - start_time) * 1000).to_i
-                sensor.instance_exec delta, *args, &proc
-              rescue Exception
-              end
+              delta = ((Time.now - start_time) * 1000).to_i
+              receiver.instance_exec(delta, *args, &handler)
+            rescue StandardError
             end
-            result
           end
-          alias_method method, with_observer
         end
       end
 
-      private
+      def chain_block(method, receiver, &handler)
+        with_observer = method_with_observer(method)
+        without_observer = method_without_observer(method)
+        me = self
+
+        Proc.new do 
+          alias_method(without_observer, method)
+          method_owner = self
+          me.send(:define_instrumented_method, method_owner, method, receiver, &handler)
+          alias_method(method, with_observer)
+        end
+      end
 
       def metaclass(klass)
         klass.class_eval do

data/lib/pulse-meter/sensor.rb

@@ -6,12 +6,14 @@ require 'pulse-meter/sensor/hashed_counter'
 require 'pulse-meter/sensor/hashed_indicator'
 require 'pulse-meter/sensor/multi'
 require 'pulse-meter/sensor/uniq_counter'
+require 'pulse-meter/sensor/timeline_reduce'
 require 'pulse-meter/sensor/timeline'
 require 'pulse-meter/sensor/timelined/average'
 require 'pulse-meter/sensor/timelined/counter'
 require 'pulse-meter/sensor/timelined/indicator'
 require 'pulse-meter/sensor/timelined/hashed_counter'
 require 'pulse-meter/sensor/timelined/hashed_indicator'
+require 'pulse-meter/sensor/timelined/zset_based'
 require 'pulse-meter/sensor/timelined/min'
 require 'pulse-meter/sensor/timelined/max'
 require 'pulse-meter/sensor/timelined/percentile'

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

@@ -6,9 +6,9 @@ module PulseMeter
     #   one value for each consequent time interval.
     class Timeline < Base
       include PulseMeter::Mixins::Utils
+      include PulseMeter::Sensor::TimelineReduce
 
       MAX_TIMESPAN_POINTS = 1000
-      MAX_INTERVALS = 100
 
       # @!attribute [r] interval
       #   @return [Fixnum] Rotation interval
@@ -64,51 +64,6 @@ module PulseMeter
         false
       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)
-          if redis.setnx(interval_data_key, value)
-            redis.expire(interval_data_key, ttl)
-          end
-        end
-      end
-
-      # Reduces data in all raw interval
-      def reduce_all_raw
-        time = Time.now
-        min_time = time - reduce_delay  - interval
-        max_depth = time - reduce_delay - interval * MAX_INTERVALS
-        ids = []
-        while (time > max_depth)
-          time -= interval
-          interval_id = get_interval_id(time)
-          next if Time.at(interval_id) > min_time
-
-          reduced_key = data_key(interval_id)
-          raw_key = raw_data_key(interval_id)
-          break if redis.exists(reduced_key)
-          ids << interval_id
-        end
-        ids.reverse.each {|id| reduce(id)}
-      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>]
@@ -128,31 +83,12 @@ module PulseMeter
       def timeline_within(from, till, skip_optimization = false)
         raise ArgumentError unless from.kind_of?(Time) && till.kind_of?(Time)
         start_time, end_time = from.to_i, till.to_i
-        actual_interval = if skip_optimization
-          interval
-        else
-          optimized_interval(start_time, end_time)
-        end
-        current_interval_id = get_interval_id(start_time) + actual_interval
-        keys = []
-        ids = []
-        while current_interval_id < end_time
-          ids << current_interval_id
-          keys << data_key(current_interval_id)
-          current_interval_id += actual_interval
-        end
-        values = keys.empty? ? [] : redis.mget(*keys)
-        res = []
-        ids.zip(values) do |(id, val)|
-          res << if val.nil?
-            get_raw_value(id)
-          else
-            sensor_data(id, val)
-          end
-        end
-        res
+        actual_interval = optimized_interval(start_time, end_time, skip_optimization)
+        start_interval_id = get_interval_id(start_time) + actual_interval
+        ids, values = fetch_reduced_interval_data(start_interval_id, actual_interval, end_time)
+        zip_with_raw_data(ids, values)
       end
-
+      
       # Returns sensor data for given interval making in-memory summarization
       #   and returns calculated value
       # @param interval_id [Fixnum]
@@ -261,8 +197,9 @@ module PulseMeter
       # @param start_time [Fixnum] unix timestamp of timespan start
       # @param end_time [Fixnum] unix timestamp of timespan start
       # @return [Fixnum] optimized interval in seconds.
-      def optimized_interval(start_time, end_time)
+      def optimized_interval(start_time, end_time, skip_optimization = false)
         res_interval = interval
+        return res_interval if skip_optimization
         timespan = end_time - start_time
         while timespan / res_interval > MAX_TIMESPAN_POINTS - 1
           res_interval *= 2
@@ -270,7 +207,30 @@ module PulseMeter
         res_interval
       end
 
+      def fetch_reduced_interval_data(start_interval_id, actual_interval, end_time)
+        keys = []
+        ids = []
+        current_interval_id = start_interval_id
+        while current_interval_id < end_time
+          ids << current_interval_id
+          keys << data_key(current_interval_id)
+          current_interval_id += actual_interval
+        end
+        values = keys.empty? ? [] : redis.mget(*keys)
+        [ids, values]
+      end
 
+      def zip_with_raw_data(ids, values)
+        res = []
+        ids.zip(values) do |(id, val)|
+          res << if val.nil?
+            get_raw_value(id)
+          else
+            sensor_data(id, val)
+          end
+        end
+        res
+      end
     end
   end
 end

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

@@ -0,0 +1,68 @@
+module PulseMeter
+  module Sensor
+    # Methods for reducing raw data to single values
+    module TimelineReduce
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      MAX_INTERVALS = 100
+
+      # @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)
+          if redis.setnx(interval_data_key, value)
+            redis.expire(interval_data_key, ttl)
+          end
+        end
+      end
+
+      # Reduces data in all raw intervals
+      def reduce_all_raw
+        time = Time.now
+        min_time = time - reduce_delay  - interval
+        max_depth = time - reduce_delay - interval * MAX_INTERVALS
+        ids = collect_ids_to_reduce(time, max_depth, min_time)
+        ids.reverse.each {|id| reduce(id)}
+      end
+
+      def collect_ids_to_reduce(time, time_from, time_to)
+        ids = []
+        while (time > time_from) # go backwards
+          time -= interval
+          interval_id = get_interval_id(time)
+          next if Time.at(interval_id) > time_to
+
+          reduced_key = data_key(interval_id)
+          raw_key = raw_data_key(interval_id)
+          break if redis.exists(reduced_key)
+          ids << interval_id
+        end
+        ids
+      end
+
+      module ClassMethods
+
+        def reduce_all_raw
+          list_objects.each do |sensor|
+            sensor.reduce_all_raw if sensor.respond_to? :reduce_all_raw
+          end
+        end
+
+      end
+
+    end
+  end
+end
+

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

@@ -2,27 +2,15 @@ module PulseMeter
   module Sensor
     module Timelined
       # Calculates max value in interval
-      class Max < Timeline
+      class Max < ZSetBased
 
-        def aggregate_event(key, value)
-          command_aggregator.zadd(key, value, "#{value}::#{uniqid}")
+        def update(key)
           command_aggregator.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)
-          else
-            nil
-          end
-        end
-
-        private
-        
-        def deflate(value)
-          value.to_f
+        def calculate(key, _)
+          max_el = redis.zrange(key, -1, -1)[0]
+          redis.zscore(key, max_el)
         end
 
       end

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

@@ -2,27 +2,15 @@ module PulseMeter
   module Sensor
     module Timelined
       # Calculates min value in interval
-      class Min < Timeline
+      class Min < ZSetBased
 
-        def aggregate_event(key, value)
-          command_aggregator.zadd(key, value, "#{value}::#{uniqid}")
+        def update(key)
           command_aggregator.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)
-          else
-            nil
-          end
-        end
-
-        private
-
-        def deflate(value)
-          value.to_f
+        def calculate(key, _)
+          min_el = redis.zrange(key, 0, 0)[0]
+          redis.zscore(key, min_el)
         end
 
       end

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

@@ -2,7 +2,7 @@ module PulseMeter
   module Sensor
     module Timelined
       # Calculates n'th percentile in interval
-      class MultiPercentile < Timeline
+      class MultiPercentile < ZSetBased
         attr_reader :p_value
 
         def initialize(name, options)
@@ -11,22 +11,13 @@ module PulseMeter
           super(name, options)
         end
 
-        def aggregate_event(key, value)
-          command_aggregator.zadd(key, value, "#{value}::#{uniqid}")
-        end
-
-        def summarize(key)
-          @p_value.each_with_object({}) do |p, acc|
-            count = redis.zcard(key)
-            percentile = if count > 0
-              position = p > 0 ? (p * count).round - 1 : 0
-              el = redis.zrange(key, position, position)[0]
-              redis.zscore(key, el)
-            else
-              nil
-            end
-            acc[p] = percentile
-          end.to_json
+        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

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

@@ -2,7 +2,7 @@ module PulseMeter
   module Sensor
     module Timelined
       # Calculates n'th percentile in interval
-      class Percentile < Timeline
+      class Percentile < ZSetBased
         attr_reader :p_value
 
         def initialize(name, options)
@@ -10,25 +10,10 @@ module PulseMeter
           super(name, options)
         end
 
-        def aggregate_event(key, value)
-          command_aggregator.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)
-          else
-            nil
-          end
-        end
-
-        private
-        
-        def deflate(value)
-          value.to_f
+        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

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

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

@@ -1,3 +1,3 @@
 module PulseMeter
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/lib/pulse-meter/visualize/public/css/application.css

@@ -38,3 +38,14 @@
 #dynamic-plotarea {
 }
 
+.ui-timepicker-div .ui-widget-header { margin-bottom: 8px; }
+.ui-timepicker-div dl { text-align: left; }
+.ui-timepicker-div dl dt { height: 25px; margin-bottom: -25px; }
+.ui-timepicker-div dl dd { margin: 0 10px 10px 65px; }
+.ui-timepicker-div td { font-size: 90%; }
+.ui-tpicker-grid-label { background: none; border: none; margin: 0; padding: 0; }
+
+.modal-body hr {
+  margin-top: 0px;
+  margin-bottom: 4px;
+}

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

@@ -25,22 +25,6 @@ module PulseMeter
 
       protected
 
-      def ensure_sensor_match!
-        intervals = []
-        sensors.each do |s|
-          unless s.type < PulseMeter::Sensor::Timeline
-            raise NotATimelinedSensorInWidget, "sensor `#{s.name}' is not timelined"
-          end
-          intervals << s.interval
-        end
-
-        unless intervals.all?{|i| i == intervals.first}
-          interval_notice = sensors.map{|s| "#{s.name}: #{s.interval}"}.join(', ')
-          raise DifferentSensorIntervalsInWidget, "Sensors with different intervals in a single widget: #{interval_notice}"
-        end
-      end
-
-
       def gauge_series_data
         ensure_gauge_indicators!
         sensors.map do |s|

data/lib/pulse-meter/visualize/widgets/timeline.rb

@@ -43,7 +43,7 @@ module PulseMeter
         end
 
         def series_data(from, till)
-          ensure_sensor_match!
+          ensure_equal_intervals!
           sensor_datas = sensors.map{ |s|
             s.timeline_data(from, till, show_last_point)
           }
@@ -73,7 +73,7 @@ module PulseMeter
           }
         end
 
-        def ensure_sensor_match!
+        def ensure_equal_intervals!
           intervals = []
           sensors.each do |s|
             unless s.type < PulseMeter::Sensor::Timeline

data/spec/pulse_meter/mixins/cmd_spec.rb

@@ -1,16 +1,21 @@
 require 'spec_helper'
 
 describe PulseMeter::Mixins::Cmd do
-  class Dummy
-    extend PulseMeter::Mixins::Cmd
+  class CmdDummy
+    include PulseMeter::Mixins::Cmd
 
-    def self.options
-      {host: :localhost, port: 6379, db: 0}
+    def initialize(redis)
+      @redis = redis
+    end
+
+    def create_redis
+      @redis
     end
   end
 
-  let(:dummy){ Dummy }
-  before {PulseMeter.redis = Redis.new}
+  let(:redis){ MockRedis.new }
+  let(:dummy){ CmdDummy.new(redis) }
+  before{ PulseMeter.redis = redis }
 
   describe "#fail!" do
     it "prints given message and exits" do

data/spec/pulse_meter/mixins/utils_spec.rb

@@ -181,4 +181,24 @@ describe PulseMeter::Mixins::Utils do
       subsets.sort.should == [[], [1], [2], [1, 2]].sort
     end
   end
+
+  describe '#parse_time' do
+    context "when argument is a valid YYYYmmddHHMMSS string" do
+      it "should correct Time object" do
+        t = dummy.parse_time("19700101000000")
+        t.should be_kind_of(Time)
+        t.to_i.should == 0
+      end
+    end
+    context "when argument is an invalid YYYYmmddHHMMSS string" do
+      it "should raise ArgumentError" do
+        expect{ dummy.parse_time("19709901000000") }.to raise_exception(ArgumentError)
+      end
+    end
+    context "when argument is not a YYYYmmddHHMMSS string" do
+      it "should raise ArgumentError" do
+        expect{ dummy.parse_time("197099010000000") }.to raise_exception(ArgumentError)
+      end
+    end
+  end
 end

data/spec/pulse_meter/observer_spec.rb

@@ -4,7 +4,7 @@ describe PulseMeter::Observer do
 
   context "instance methods observation" do
   
-    class Dummy
+    class ObservedDummy
       attr_reader :count
 
       def initialize
@@ -23,20 +23,20 @@ describe PulseMeter::Observer do
       end
     end
 
-    let!(:dummy) {Dummy.new}
+    let!(:dummy) {ObservedDummy.new}
     let!(:sensor) {PulseMeter::Sensor::Counter.new(:foo)}
     before do
-      [:incr, :error].each {|m| described_class.unobserve_method(Dummy, m)}
+      [:incr, :error].each {|m| described_class.unobserve_method(ObservedDummy, m)}
     end
 
     def create_observer(method = :incr, increment = 1)
-      described_class.observe_method(Dummy, method, sensor) do |*args|
+      described_class.observe_method(ObservedDummy, method, sensor) do |*args|
         event(increment)
       end
     end
 
     def remove_observer(method = :incr)
-      described_class.unobserve_method(Dummy, method)
+      described_class.unobserve_method(ObservedDummy, method)
     end
 
     describe ".observe_method" do
@@ -53,7 +53,7 @@ describe PulseMeter::Observer do
       end
 
       it "passes methods' params to block" do
-        described_class.observe_method(Dummy, :incr, sensor) do |time, cnt|
+        described_class.observe_method(ObservedDummy, :incr, sensor) do |time, cnt|
           event(cnt)
         end
 
@@ -63,7 +63,7 @@ describe PulseMeter::Observer do
 
       it "passes execution time in milliseconds to block" do
         Timecop.freeze do
-          described_class.observe_method(Dummy, :incr, sensor) do |time, cnt|
+          described_class.observe_method(ObservedDummy, :incr, sensor) do |time, cnt|
             event(time)
           end
 
@@ -73,7 +73,7 @@ describe PulseMeter::Observer do
       end
 
       it "does not break observed method even is observer raises error" do
-        described_class.observe_method(Dummy, :incr, sensor) do |*args|
+        described_class.observe_method(ObservedDummy, :incr, sensor) do |*args|
           raise RuntimeError
         end
 
@@ -125,7 +125,7 @@ describe PulseMeter::Observer do
 
   context "class methods observation" do
   
-    class Dummy
+    class ObservedDummy
       @@count = 0
       class << self
         def count
@@ -149,21 +149,21 @@ describe PulseMeter::Observer do
       end
     end
 
-    let!(:dummy) {Dummy}
+    let!(:dummy) {ObservedDummy}
     let!(:sensor) {PulseMeter::Sensor::Counter.new(:foo)}
     before do
       dummy.reset
-      [:incr, :error].each {|m| described_class.unobserve_class_method(Dummy, m)}
+      [:incr, :error].each {|m| described_class.unobserve_class_method(ObservedDummy, m)}
     end
 
     def create_observer(method = :incr, increment = 1)
-      described_class.observe_class_method(Dummy, method, sensor) do |*args|
+      described_class.observe_class_method(ObservedDummy, method, sensor) do |*args|
         event(increment)
       end
     end
 
     def remove_observer(method = :incr)
-      described_class.unobserve_class_method(Dummy, method)
+      described_class.unobserve_class_method(ObservedDummy, method)
     end
 
     describe ".observe_class_method" do
@@ -180,7 +180,7 @@ describe PulseMeter::Observer do
       end
 
       it "passes methods' params to block" do
-        described_class.observe_class_method(Dummy, :incr, sensor) do |time, cnt|
+        described_class.observe_class_method(ObservedDummy, :incr, sensor) do |time, cnt|
           event(cnt)
         end
 
@@ -190,7 +190,7 @@ describe PulseMeter::Observer do
 
       it "passes execution time in milliseconds to block" do
         Timecop.freeze do
-          described_class.observe_class_method(Dummy, :incr, sensor) do |time, cnt|
+          described_class.observe_class_method(ObservedDummy, :incr, sensor) do |time, cnt|
             event(time)
           end
 
@@ -200,7 +200,7 @@ describe PulseMeter::Observer do
       end
 
       it "does not break observed method even is observer raises error" do
-        described_class.observe_class_method(Dummy, :incr, sensor) do |*args|
+        described_class.observe_class_method(ObservedDummy, :incr, sensor) do |*args|
           raise RuntimeError
         end
 

data/spec/spec_helper.rb

@@ -10,6 +10,8 @@ SimpleCov.start
 
 require 'pulse-meter'
 require 'pulse-meter/visualizer'
+PulseMeter.redis = MockRedis.new
+
 require 'rack/test'
 
 Dir['spec/support/**/*.rb'].each{|f| require File.join(ROOT, f) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pulse-meter
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-11 00:00:00.000000000 Z
+date: 2013-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gon-sinatra
@@ -429,6 +429,7 @@ files:
 - lib/pulse-meter/sensor/indicator.rb
 - lib/pulse-meter/sensor/multi.rb
 - lib/pulse-meter/sensor/timeline.rb
+- lib/pulse-meter/sensor/timeline_reduce.rb
 - lib/pulse-meter/sensor/timelined/average.rb
 - lib/pulse-meter/sensor/timelined/counter.rb
 - lib/pulse-meter/sensor/timelined/hashed_counter.rb
@@ -440,6 +441,7 @@ files:
 - lib/pulse-meter/sensor/timelined/multi_percentile.rb
 - lib/pulse-meter/sensor/timelined/percentile.rb
 - lib/pulse-meter/sensor/timelined/uniq_counter.rb
+- lib/pulse-meter/sensor/timelined/zset_based.rb
 - lib/pulse-meter/sensor/uniq_counter.rb
 - lib/pulse-meter/server.rb
 - lib/pulse-meter/server/command_line_options.rb
@@ -605,6 +607,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1795310197501122422
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23