pulse-meter 0.2.7 → 0.2.8

data/lib/pulse-meter/extensions/enumerable.rb

@@ -0,0 +1,24 @@
+module Enumerable
+  require 'csv'
+  require 'terminal-table'
+
+  def convert_time
+    map {|el| el.is_a?(Time) ? el.to_i : el}
+  end
+
+  def to_table(format = nil)
+    if "csv" == format.to_s
+      CSV.generate(:col_sep => ';') do |csv|
+        self.each {|row| csv << row.convert_time}
+      end
+    else
+      self.each_with_object(Terminal::Table.new) do |row, table|
+        table << if row.respond_to?(:map)
+          row.map(&:to_s)
+        else
+          row
+        end
+      end
+    end
+  end
+end

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

@@ -1,30 +1,4 @@
-module Enumerable
-  def convert_time
-    map do |el|
-      if el.is_a?(Time)
-        el.to_i
-      else
-        el
-      end
-    end
-  end
-
-  def to_table(format = nil)
-    if "csv" == format
-      CSV.generate(:col_sep => ';') do |csv|
-        self.each {|row| csv << row.convert_time}
-      end
-    else
-      self.each_with_object(Terminal::Table.new) do |row, table|
-        table << if row.respond_to?(:map)
-          row.map(&:to_s)
-        else
-          row
-        end
-      end
-    end
-  end
-end
+require 'pulse-meter/extensions/enumerable'
 
 module PulseMeter
   module Mixins
@@ -52,7 +26,7 @@ module PulseMeter
         data = [
           ["Name", "Class", "ttl", "raw data ttl", "interval", "reduce delay"],
         ]
-        data << :separator unless format == 'csv'
+        data << :separator unless 'csv' == format.to_s
         all_sensors.each do |s|
           if s.kind_of? PulseMeter::Sensor::Timeline
             data << [s.name, s.class, s.ttl, s.raw_data_ttl, s.interval, s.reduce_delay]

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

@@ -1,11 +1,16 @@
 module PulseMeter
   module Sensor
+    # Constructs multiple sensors from configuration passed 
     class Configuration
       include PulseMeter::Mixins::Utils
       include Enumerable
 
+      # @!attribute [r] sensors
+      #   @return [Hash] hash of sensors with names as keys and sensors as values 
       attr_reader :sensors
 
+      # Initializes sensors
+      # @param opts [Hash] sensors' configuration
       def initialize(opts = {})
         @sensors = {}
         opts.each do |name, opts|
@@ -13,6 +18,9 @@ module PulseMeter
         end
       end
 
+      # Adds sensor
+      # @param name [Symbol] sensor name
+      # @param opts [Hash] sensor options
       def add_sensor(name, opts)
         sensor_type = opts.respond_to?(:sensor_type) ? opts.sensor_type : opts[:sensor_type]
         klass_s = sensor_class(sensor_type)
@@ -22,16 +30,22 @@ module PulseMeter
         @sensors[name.to_s] = klass.new(name, symbolize_keys(args.to_hash))
       end
 
+      # Returns previously initialized sensor by name
+      # @param name [Symbol] sensor name
+      # @return [Sensor] sensor 
       def sensor(name)
         @sensors[name.to_s]
       end
 
+      # Iterates over each sensor
       def each
         @sensors.each_value do |sensor|
           yield(sensor)
         end
       end
 
+      # Invokes event for any sensor 
+      # @raise [ArgumentError] unless sensor exists
       def method_missing(name, *args)
         name = name.to_s
         if @sensors.has_key?(name)

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

@@ -25,7 +25,10 @@ module PulseMeter
       # @param data [Hash] hash where keys represent counter keys
       #   and values are increments for their keys
       def process_event(data)
-        data.each_pair {|k, v| redis.hincrby(value_key, k, v.to_i)}
+        data.each_pair do |k, v|
+          redis.hincrby(value_key, k, v.to_i)
+          redis.hincrby(value_key, :total, v.to_i)
+        end
       end
 
     end

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

@@ -108,12 +108,17 @@ module PulseMeter
       # Returts sensor data within given time
       # @param from [Time] lower bound
       # @param till [Time] upper bound
+      # @param skip_optimization [Boolean] must be set to true to skip interval optimization
       # @return [Array<SensorData>]
       # @raise ArgumentError if argumets are not valid time objects
-      def timeline_within(from, till)
+      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 = optimized_inteval(start_time, end_time)
+        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 = []
@@ -134,19 +139,6 @@ module PulseMeter
         res
       end
 
-      # Makes interval optimization so that the requested timespan contains less than MAX_TIMESPAN_POINTS values
-      # @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_inteval(start_time, end_time)
-        res_interval = interval
-        timespan = end_time - start_time
-        while timespan / res_interval > MAX_TIMESPAN_POINTS - 1
-          res_interval *= 2
-        end
-        res_interval
-      end
-
       # Returns sensor data for given interval making in-memory summarization
       #   and returns calculated value
       # @param interval_id [Fixnum]
@@ -174,11 +166,7 @@ module PulseMeter
           keys << raw_data_key(current_interval_id)
           current_interval_id += interval
         end
-        if keys.empty?
-          0
-        else
-          redis.del(*keys)
-        end
+        keys.empty? ? 0 : redis.del(*keys)
       end
 
       # Returns Redis key by which raw data for current interval is stored
@@ -255,6 +243,20 @@ module PulseMeter
         end
       end
 
+      # Makes interval optimization so that the requested timespan contains less than MAX_TIMESPAN_POINTS values
+      # @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)
+        res_interval = interval
+        timespan = end_time - start_time
+        while timespan / res_interval > MAX_TIMESPAN_POINTS - 1
+          res_interval *= 2
+        end
+        res_interval
+      end
+
+
     end
   end
 end

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

@@ -7,7 +7,10 @@ module PulseMeter
       # 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)}
+          data.each_pair do |k, v|
+            redis.hincrby(key, k, v)
+            redis.hincrby(key, :total, v)
+          end
         end
 
         def summarize(key)

data/lib/pulse-meter/version.rb

@@ -1,3 +1,3 @@
 module PulseMeter
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 end

data/spec/pulse_meter/extensions/enumerable_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'pulse-meter/extensions/enumerable'
+
+describe Enumerable do
+  let!(:time) {Time.new}
+  describe "#convert_time" do
+    it "converts Time objects to unixtime" do
+      [time].convert_time.should == [time.to_i]
+    end
+
+    it "does not change other members" do
+      [1, 2, 3].convert_time.should == [1, 2 ,3]
+    end
+  end
+
+  describe "#to_table" do
+    context "when format is csv" do
+      it "returns csv as string" do
+        [].to_table(:csv).should be_instance_of(String)
+      end
+
+      it "returns csv containing each subarray as a row" do
+        [[:a, :b], [:c, :d]].to_table(:csv).should == "a;b\nc;d\n"
+      end
+
+      it "converts Time objects to unixtime" do
+        [[time]].to_table(:csv).should == "#{time.to_i}\n"
+      end
+
+      it "takes format argument both as string and as symbol" do
+        [[:foo]].to_table("csv").should == "foo\n"
+        [[:foo]].to_table(:csv).should == "foo\n"
+      end
+    end
+
+    context "when format is table" do
+      it "return Terminal::Table instance" do
+        [].to_table.should be_instance_of(Terminal::Table)
+      end
+
+      it "returns table containing each subarray as a row" do
+        data = [[:a, :b], [:c, :d]]
+        table = [[:a, :b], [:c, :d]].to_table
+        table.rows.map do |row|
+          row.cells.map(&:to_s).map(&:strip).map(&:to_sym)
+        end.should == data
+      end
+    end
+
+    it "uses table format as default" do
+      [].to_table.should be_instance_of(Terminal::Table)
+    end
+
+    it "uses table format unless it is :csv or 'csv'" do
+      [].to_table(:unknown_format).should be_instance_of(Terminal::Table)
+    end
+  end
+end

data/spec/pulse_meter/mixins/cmd_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe PulseMeter::Mixins::Cmd do
+  class Dummy
+    extend PulseMeter::Mixins::Cmd
+
+    def self.options
+      {host: :localhost, port: 6379, db: 0}
+    end
+  end
+
+  let(:dummy){ Dummy }
+  before {PulseMeter.redis = Redis.new}
+
+  describe "#fail!" do
+    it "prints given message and exits" do
+      STDOUT.should_receive(:puts).with(:msg)
+      lambda {dummy.fail!(:msg)}.should raise_error(SystemExit)
+    end
+  end
+
+  describe '#with_redis' do
+    it "initializes redies and yields a block" do
+      PulseMeter.redis = nil
+      dummy.with_redis do
+        PulseMeter.redis.should_not be_nil
+      end
+    end
+  end
+
+  describe "#with_safe_restore_of" do
+    it "restores sensor by name and passes it to block" do
+      sensor = PulseMeter::Sensor::Counter.new(:foo)
+      dummy.with_safe_restore_of(:foo) do |s|
+        s.should be_instance_of(sensor.class)
+      end
+    end
+
+    it "prints error and exits if sensor cannot be restored" do
+      STDOUT.should_receive(:puts).with("Sensor nonexistant is unknown or cannot be restored")
+      lambda {dummy.with_safe_restore_of(:nonexistant) {|s| s}}.should raise_error(SystemExit)
+    end
+  end
+
+  describe "#all_sensors" do
+    it "is just an alias to PulseMeter::Sensor::Timeline.list_objects" do
+      PulseMeter::Sensor::Timeline.should_receive(:list_objects)
+      dummy.all_sensors
+    end
+  end
+
+  describe "#all_sensors_table" do
+    before {PulseMeter.redis.flushall}
+    let(:init_values){ {:ttl => 1, :raw_data_ttl => 2, :interval => 3, :reduce_delay => 4} }
+    let!(:s1) {PulseMeter::Sensor::Counter.new(:s1)} 
+    let!(:s2) {PulseMeter::Sensor::Timelined::Counter.new(:s2, init_values)} 
+    let!(:table) {dummy.all_sensors_table}
+    let!(:csv) {dummy.all_sensors_table(:csv)}
+    let!(:parsed_csv) {CSV.parse(csv, col_sep: ";")}
+
+    def rows(format)
+      if "csv" == format.to_s
+        parsed_csv
+      else
+        table.rows.map do |row|
+          row.cells.map(&:to_s).map(&:strip)
+        end
+      end
+    end
+
+    def sensor_row(name, format)
+      rows(format).select {|row| row[0] == name}.first
+    end
+      
+    [:csv, :table].each do |format|
+      context "when format is #{format}" do
+
+        if "csv" == format.to_s
+          it "returns csv as string" do
+            csv.should be_instance_of(String)
+          end
+        else
+          it "returns Terminal::Table instance" do
+            table.should be_instance_of(Terminal::Table)
+          end
+        end
+
+        it "has title row" do
+          rows(format)[0].should == ["Name", "Class", "ttl", "raw data ttl", "interval", "reduce delay"]
+        end
+
+        it "has one row for each sensor (and a title)" do
+          rows(format).count.should == 3
+        end
+
+        it "can display timelined sensors" do
+          sensor_row("s2", format).should == [
+            s2.name, s2.class, s2.ttl, s2.raw_data_ttl, s2.interval, s2.reduce_delay
+          ].map(&:to_s)
+        end
+
+        it "can display static sensors" do
+          sensor_row("s1", format).should == [
+            s1.name, s1.class, "", "", "", ""
+          ].map(&:to_s)
+        end
+
+      end
+    end
+  end
+
+end

data/spec/pulse_meter/sensor/hashed_counter_spec.rb

@@ -15,6 +15,10 @@ describe PulseMeter::Sensor::HashedCounter do
       expect{ sensor.event({"foo" => 10.4}) }.to change{ sensor.value["foo"] }.from(0).to(10)
       expect{ sensor.event({"foo" => 15.1}) }.to change{ sensor.value["foo"] }.from(10).to(25)
     end
+
+    it "should increment total value" do
+      expect{ sensor.event({"foo" => 1, "bar" => 2}) }.to change{sensor.value["total"]}.from(0).to(3)
+    end
   end
 
   describe "#value" do
@@ -24,8 +28,8 @@ describe PulseMeter::Sensor::HashedCounter do
 
     it "should store redis hash by value_key" do
       sensor.event({"foo" => 1})
-      sensor.value.should == {"foo" => 1}
-      redis.hgetall(sensor.value_key).should == {"foo" => "1"}
+      sensor.value.should == {"foo" => 1, "total" => 1}
+      redis.hgetall(sensor.value_key).should == {"foo" => "1", "total" => "1"}
     end
   end
 

data/spec/pulse_meter/sensor/timelined/hashed_counter_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe PulseMeter::Sensor::Timelined::HashedCounter do
   it_should_behave_like "timeline sensor", {}, {:foo => 1}
-  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => 2}], {:foo => 3}.to_json
-  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => :bad_value}], {:foo => 1}.to_json
-  it_should_behave_like "timelined subclass", [{:foo => 1}, {:boo => 2}], {:foo => 1, :boo => 2}.to_json
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => 2}], {:foo => 3, :total => 3}.to_json
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => :bad_value}], {:foo => 1, :total => 1}.to_json
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:boo => 2}], {:foo => 1, :boo => 2, :total => 3}.to_json
 end

data/spec/shared_examples/timeline_sensor.rb

@@ -242,12 +242,32 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
       end
     end
 
-    it "should not return more than #{PulseMeter::Sensor::Timeline::MAX_TIMESPAN_POINTS} points" do
-      max = PulseMeter::Sensor::Timeline::MAX_TIMESPAN_POINTS
-      (1..10).each do |i|
-        timespan = sensor.interval * max * (2**i)
-        sensor.timeline_within(Time.now, Time.now - timespan).size.should < max
+    context "to avoid getting to much data" do
+      let(:max) {PulseMeter::Sensor::Timeline::MAX_TIMESPAN_POINTS}
 
+      it "should skip some points not to exceed MAX_TIMESPAN_POINTS" do
+        count = max * 2
+        sensor.timeline_within(
+          Time.at(@start_of_interval - 1),
+          Time.at(@start_of_interval + count * interval)
+        ).size.should < max
+      end
+
+      it "should not skip any points when timeline orginal size is less then MAX_TIMESPAN_POINTS" do
+        count = max - 1
+        sensor.timeline_within(
+          Time.at(@start_of_interval - 1),
+          Time.at(@start_of_interval + count * interval)
+        ).size.should == count
+      end
+
+      it "should give full data in case skip_optimization parameter set to true" do
+        count = max * 2
+        sensor.timeline_within(
+          Time.at(@start_of_interval - 1),
+          Time.at(@start_of_interval + count * interval),
+          true
+        ).size.should == count
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pulse-meter
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-23 00:00:00.000000000 Z
+date: 2012-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gon-sinatra
@@ -333,6 +333,7 @@ files:
 - examples/server_config.yml
 - lib/cmd.rb
 - lib/pulse-meter.rb
+- lib/pulse-meter/extensions/enumerable.rb
 - lib/pulse-meter/mixins/cmd.rb
 - lib/pulse-meter/mixins/dumper.rb
 - lib/pulse-meter/mixins/utils.rb
@@ -405,6 +406,8 @@ files:
 - lib/pulse-meter/visualize/widgets/timeline.rb
 - lib/pulse-meter/visualizer.rb
 - pulse-meter.gemspec
+- spec/pulse_meter/extensions/enumerable_spec.rb
+- spec/pulse_meter/mixins/cmd_spec.rb
 - spec/pulse_meter/mixins/dumper_spec.rb
 - spec/pulse_meter/mixins/utils_spec.rb
 - spec/pulse_meter/sensor/base_spec.rb
@@ -472,7 +475,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -450227772948230282
+      hash: -2299028715226414900
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -481,6 +484,8 @@ specification_version: 3
 summary: Lightweight Redis-based metrics aggregator and processor with CLI and simple
   and customizable WEB interfaces
 test_files:
+- spec/pulse_meter/extensions/enumerable_spec.rb
+- spec/pulse_meter/mixins/cmd_spec.rb
 - spec/pulse_meter/mixins/dumper_spec.rb
 - spec/pulse_meter/mixins/utils_spec.rb
 - spec/pulse_meter/sensor/base_spec.rb