pulse-meter-client-backport 0.1.0

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

data/lib/pulse-meter/version.rb

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

data/pulse-meter-client-backport.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/pulse-meter/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ilya Averyanov", "Sergey Averyanov"]
+  gem.email         = ["av@fun-box.ru", "averyanov@gmail.com"]
+  gem.description   = %q{Ruby 1.8 compatible PulseMeter client}
+  gem.summary       = %q{
+    Ruby 1.8 compatible PulseMeter client
+  }
+  gem.homepage      = ""
+
+  gem.required_ruby_version = '~> 1.8.0'
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "pulse-meter-client-backport"
+  gem.require_paths = ["lib"]
+  gem.version       = PulseMeter::VERSION
+
+  gem.add_runtime_dependency('json')
+  gem.add_runtime_dependency('redis')
+
+  gem.add_development_dependency('foreman')
+  gem.add_development_dependency('mock_redis')
+  gem.add_development_dependency('rack-test')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('redcarpet')
+  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('timecop')
+  gem.add_development_dependency('yard')
+
+end

data/spec/pulse_meter/mixins/dumper_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe PulseMeter::Mixins::Dumper do
+  class Base
+    include PulseMeter::Mixins::Dumper
+  end
+
+  class Bad < Base; end
+
+  class Good < Base
+    attr_accessor :foo
+    def name; foo.to_s; end
+
+    def redis; PulseMeter.redis; end
+
+    def initialize(foo)
+      @foo = foo
+    end
+  end
+
+  let(:bad_obj){ Bad.new }
+  let(:good_obj){ Good.new(:foo) }
+  let(:another_good_obj){ Good.new(:bar) }
+  let(:redis){ PulseMeter.redis }
+
+  describe '#dump' do
+    context "when class violates dump contract" do
+      context "when it has no name attribute" do
+        it "should raise exception" do
+          def bad_obj.redis; PulseMeter.redis; end
+          expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
+        end
+      end
+
+      context "when it has no redis attribute" do
+        it "should raise exception" do
+          def bad_obj.name; :foo; end
+          expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
+        end
+      end
+
+      context "when redis is not avalable" do
+        it "should raise exception" do
+          def bad_obj.name; :foo; end
+          def bad_obj.redis; nil; end
+          expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
+        end
+      end
+    end
+
+    context "when class follows dump contract" do
+      it "should not raise dump exception" do
+        expect {good_obj.dump!}.not_to raise_exception(PulseMeter::DumpError)
+      end
+
+      it "should save dump to redis" do
+        expect {good_obj.dump!}.to change {redis.hlen(Good::DUMP_REDIS_KEY)}.by(1)
+      end
+    end
+  end
+
+  describe ".restore" do
+    context "when object has never been dumped" do
+      it "should raise exception" do
+        expect{ Base.restore(:nonexistant) }.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+    context "when object was dumped" do
+      before do
+        good_obj.dump!
+      end
+
+      it "should keep object class" do
+        Base.restore(good_obj.name).should be_instance_of(good_obj.class)
+      end
+
+      it "should restore object data" do
+        restored = Base.restore(good_obj.name)
+        restored.foo.should == good_obj.foo
+      end
+
+      it "should restore last dumped object" do
+        good_obj.foo = :bar
+        good_obj.dump!
+        restored = Base.restore(good_obj.name)
+        restored.foo.should == :bar
+      end
+    end
+  end
+
+  describe ".list_names" do
+    context "when redis is not available" do
+      before do
+        PulseMeter.stub(:redis).and_return(nil)
+      end
+
+      it "should raise exception" do
+        expect {Base.list_names}.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+    context "when redis if fine" do
+      it "should return empty list if nothing is registered" do
+        Base.list_names.should == []
+      end
+
+      it "should return list of registered objects" do
+        good_obj.dump!
+        another_good_obj.dump!
+        Base.list_names.should =~ [good_obj.name, another_good_obj.name]
+      end
+    end
+  end
+
+  describe ".list_objects" do
+    before do
+      good_obj.dump!
+      another_good_obj.dump!
+    end
+
+    it "should return restored objects" do
+      objects = Base.list_objects
+      objects.map(&:name).should =~ [good_obj.name, another_good_obj.name]
+    end
+
+    it "should skip unrestorable objects" do
+      Base.stub(:list_names).and_return([good_obj.name, "scoundrel", another_good_obj.name])
+      objects = Base.list_objects
+      objects.map(&:name).should =~ [good_obj.name, another_good_obj.name]
+    end
+  end
+
+  describe "#cleanup_dump" do
+    it "should remove data from redis" do
+      good_obj.dump!
+      another_good_obj.dump!
+      expect {good_obj.cleanup_dump}.to change{good_obj.class.list_names.count}.by(-1)
+    end
+  end
+end

data/spec/pulse_meter/mixins/utils_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe PulseMeter::Mixins::Utils do
+  class Dummy
+    include PulseMeter::Mixins::Utils
+  end
+
+  let(:dummy){ Dummy.new }
+
+  describe '#constantize' do
+    context "when argument is a string with a valid class name" do
+      it "should return class" do
+        dummy.constantize("PulseMeter::Mixins::Utils").should == PulseMeter::Mixins::Utils
+      end
+    end
+    context "when argument is a string with invalid class name" do
+      it "should return nil" do
+        dummy.constantize("Pumpkin::Eater").should be_nil
+      end
+    end
+  end
+
+  describe "#assert_positive_integer!" do
+    it "should extract integer value from hash by passed key" do
+      dummy.assert_positive_integer!({:val => 4}, :val).should == 4
+    end
+
+    context "when no default value given" do
+      context "when the value by the passed key is not integer" do
+        it "should convert non-integers to integers" do
+          dummy.assert_positive_integer!({:val => 4.4}, :val).should == 4
+        end
+
+        it "should change the original value to the obtained integer" do
+          h = {:val => 4.4}
+          dummy.assert_positive_integer!(h, :val).should == 4
+          h[:val].should == 4
+        end
+
+      end
+
+      it "should raise exception if the value is not positive" do
+        expect{ dummy.assert_positive_integer!({:val => -1}, :val) }.to raise_exception(ArgumentError)
+      end
+
+      it "should raise exception if the value is not defined" do
+        expect{ dummy.assert_positive_integer!({}, :val) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context "when default value given" do
+      it "should prefer value from options to default" do
+        dummy.assert_positive_integer!({:val => 4}, :val, 22).should == 4
+      end
+
+      it "should use default value when there is no one in options" do
+        dummy.assert_positive_integer!({}, :val, 22).should == 22
+      end
+
+      it "should check default value if it is to be used" do
+        expect{dummy.assert_positive_integer!({}, :val, -1)}.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe "#assert_ranged_float!" do
+
+    it "should extract float value from hash by passed key" do
+      dummy.assert_ranged_float!({:val => 4}, :val, 0, 100).should be_generally_equal(4)
+    end
+
+    context "when the value by the passed key is not float" do
+      it "should convert non-floats to floats" do
+        dummy.assert_ranged_float!({:val => "4.0000"}, :val, 0, 100).should be_generally_equal(4)
+      end
+
+      it "should change the original value to the obtained float" do
+        h = {:val => "4.000"}
+        dummy.assert_ranged_float!(h, :val, 0, 100).should be_generally_equal(4)
+        h[:val].should be_generally_equal(4)
+      end
+
+      it "should raise exception if the original value cannot be converted to float" do
+        expect{ dummy.assert_ranged_float!({:val => :bad_float}, :val, 0, 100) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    it "should raise exception if the value is not within range" do
+      expect{ dummy.assert_ranged_float!({:val => -0.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
+      expect{ dummy.assert_ranged_float!({:val => 100.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
+    end
+
+    it "should raise exception if the value is not defined" do
+      expect{ dummy.assert_ranged_float!({}, :val) }.to raise_exception(ArgumentError)
+    end
+  end
+
+  describe "#uniqid" do
+    it "should return uniq strings" do
+      uniq_values = (1..1000).map{|_| dummy.uniqid}
+      uniq_values.uniq.count.should == uniq_values.count
+    end
+  end
+
+  describe "#titleize" do
+    it "should convert identificator to title" do
+      dummy.titleize("aaa_bbb").should == 'Aaa Bbb'
+      dummy.titleize(:aaa_bbb).should == 'Aaa Bbb'
+      dummy.titleize("aaa bbb").should == 'Aaa Bbb'
+    end
+  end
+
+  describe "#camelize" do
+    it "should camelize string" do
+      dummy.camelize("aa_bb_cc").should == "aaBbCc"
+      dummy.camelize("aa_bb_cc", true).should == "AaBbCc"
+    end
+  end
+
+  describe "#camelize_keys" do
+    it "should deeply camelize keys in hashes" do
+      dummy.camelize_keys({ :aa_bb_cc => [ { :dd_ee => 123 }, 456 ] }).should =={ 'aaBbCc' => [ { 'ddEe' => 123 }, 456 ] }
+    end
+  end
+end

data/spec/pulse_meter/sensor/base_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Base do
+  let(:name){ :some_sensor }
+  let(:description) {"Le awesome description"}
+  let!(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe '#initialize' do
+    context 'when PulseMeter.redis is not initialized' do
+      it "should raise RedisNotInitialized exception" do
+        PulseMeter.redis = nil
+        expect{ described_class.new(:foo) }.to raise_exception(PulseMeter::RedisNotInitialized)
+      end
+    end
+
+    context 'when PulseMeter.redis is initialized' do
+
+      context 'when passed sensor name is bad' do
+        it "should raise BadSensorName exception" do
+          ['name with whitespace', 'name|with|bad|characters'].each do |bad_name|
+            expect{ described_class.new(bad_name) }.to raise_exception(PulseMeter::BadSensorName)
+          end
+        end
+      end
+
+      context 'when passed sensor name is valid' do
+        it "should successfully create object" do
+          described_class.new(:foo).should_not be_nil
+        end
+
+        it "should initialize attributes #redis and #name" do
+          sensor = described_class.new(:foo)
+          sensor.name.should == 'foo'
+          sensor.redis.should == PulseMeter.redis
+        end
+
+        it "should save dump to redis automatically to let the object be restored by name" do
+          described_class.restore(name).should be_instance_of(described_class)
+        end
+
+        it "should annotate object if annotation given" do
+          described_class.new(:foo, :annotation => "annotation")
+          sensor = described_class.restore(:foo)
+          sensor.annotation.should == "annotation"
+        end
+      end
+    end
+  end
+
+  describe '#annotate' do
+
+    it "should store sensor annotation in redis" do
+      expect {sensor.annotate(description)}.to change{redis.keys('*').count}.by(1)
+    end
+
+  end
+
+  describe '#annotation' do
+    context "when sensor was annotated" do
+      it "should return stored annotation" do
+        sensor.annotate(description)
+        sensor.annotation.should == description
+      end
+    end
+
+    context "when sensor was not annotated" do
+      it "should return nil" do
+        sensor.annotation.should be_nil
+      end
+    end
+
+    context "after sensor data was cleaned" do
+      it "should return nil" do
+        sensor.annotate(description)
+        sensor.cleanup
+        sensor.annotation.should be_nil
+      end
+    end
+  end
+
+  describe "#cleanup" do
+    it "should remove from redis all sensor data" do
+      sensor.event(123)
+      sensor.annotate(description)
+      sensor.cleanup
+      redis.keys('*').should be_empty
+    end
+  end
+
+  describe "#event" do
+    it "should actually do nothing for base sensor" do
+      sensor.event(nil)
+    end
+  end
+
+end