pulse-meter 0.0.1

data/spec/pulse_meter/visualize/sensor_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::Sensor do
+  let(:interval){ 100 }
+  let(:name) { "some_sensor" }
+  let(:annotation) { 'sensor descr' }
+  let!(:real_sensor){ PulseMeter::Sensor::Timelined::Counter.new(name, ttl: 1000, interval: interval, annotation: annotation) }
+  let(:sensor) { described_class.new(sensor: name) }
+
+  let(:color){ '#ABCDEF' }
+  let(:sensor_with_color) { described_class.new(sensor: name, color: color) }
+
+  let(:bad_sensor) { described_class.new(sensor: "bad_sensor_name") }
+  let(:interval_start){ Time.at((Time.now.to_i / interval) * interval) }
+
+  describe '#last_value' do
+    context "when sensor does not exist" do
+      it "should raise RestoreError" do
+        expect{ bad_sensor.last_value }.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+
+    context "when sensor has no data" do
+      it "should return nil" do
+        sensor.last_value.should be_nil
+      end
+    end
+
+    context "when sensor has data" do
+      context "when need_incomplete arg is true" do
+        it "should return last value" do
+          Timecop.freeze(interval_start) do
+            real_sensor.event(101)
+          end
+          Timecop.freeze(interval_start+1) do
+            sensor.last_value(true).should == 101
+          end
+        end
+      end
+
+      context "when need_incomplete arg is false" do
+        it "should return last complete value" do
+          Timecop.freeze(interval_start) do
+            real_sensor.event(101)
+          end
+          Timecop.freeze(interval_start + 1) do
+            sensor.last_value.should be_nil
+          end
+          Timecop.freeze(interval_start + interval + 1) do
+            sensor.last_value.should == 101
+          end
+        end
+      end
+
+    end
+  end
+
+  describe "#last_point_data" do
+
+    context "when sensor does not exist" do
+      it "should raise RestoreError" do
+        expect{ bad_sensor.last_point_data }.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+    it "should return last value with annotation (and color)" do
+      Timecop.freeze(interval_start) do
+        real_sensor.event(101)
+      end
+      Timecop.freeze(interval_start + 1) do
+        sensor.last_point_data(true).should == {name: annotation, y: 101}
+        sensor.last_point_data.should == {name: annotation, y: nil}
+        sensor_with_color.last_point_data(true).should == {name: annotation, y: 101, color: color}
+        sensor_with_color.last_point_data.should == {name: annotation, y: nil, color: color}
+      end
+    end
+  end
+
+  describe "#timeline_data" do
+    before(:each) do
+      Timecop.freeze(interval_start) do
+        real_sensor.event(101)
+      end
+      Timecop.freeze(interval_start + interval) do
+        real_sensor.event(55)
+      end
+    end
+
+    context "when sensor does not exist" do
+      it "should raise RestoreError" do
+        expect{ bad_sensor.timeline_data(interval) }.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+
+    describe "returned value" do
+      it "should contain sensor annotation" do
+        Timecop.freeze(interval_start + interval + 1) do
+          sensor.timeline_data(interval)[:name].should == annotation
+        end
+      end
+      it "should contain sensor color" do
+        Timecop.freeze(interval_start + interval + 1) do
+          sensor_with_color.timeline_data(interval)[:color].should == color
+        end
+      end
+
+      it "should contain [interval_start, value] pairs for each interval" do
+        Timecop.freeze(interval_start + interval + 1) do
+          data = sensor.timeline_data(interval * 2)
+          data[:data].should == [{x: interval_start.to_i * 1000, y: 101}]
+          data = sensor.timeline_data(interval * 2, true)
+          data[:data].should == [{x: interval_start.to_i * 1000, y: 101}, {x: (interval_start + interval).to_i * 1000, y: 55}]
+        end
+      end
+    end
+  end
+
+end

data/spec/pulse_meter/visualize/widget_spec.rb

@@ -0,0 +1,113 @@
+require "spec_helper"
+
+describe PulseMeter::Visualize::Widget do
+  let(:interval){ 100 }
+  let!(:a_sensor){ PulseMeter::Sensor::Timelined::Counter.new(:a_sensor, :ttl => 1000, :interval => interval, annotation: 'A') }
+  let!(:b_sensor){ PulseMeter::Sensor::Timelined::Counter.new(:b_sensor, :ttl => 1000, :interval => interval, annotation: 'B') }
+
+  let(:type) { :some_type }
+  let(:widget_name){ "some_widget" }
+
+  let(:redraw_interval){5}
+  let(:values_label){'xxxx'}
+  let(:width){6}
+  let(:show_last_point){false}
+  let(:timespan){interval * 2}
+  let(:a_color){'#FF0000'}
+  let(:b_color){'#FFFF00'}
+
+  let(:interval_start){ Time.at((Time.now.to_i / interval) * interval) }
+
+  def add_widget_settings(w)
+    w.redraw_interval redraw_interval
+    w.values_label values_label
+    w.width width
+    w.show_last_point show_last_point
+    w.timespan timespan
+
+    w.sensor :a_sensor, color: a_color
+    w.sensor :b_sensor, color: b_color
+  end
+
+  let(:widgets) do
+    [:line, :spline, :area, :pie].each_with_object({}) do |type, h|
+      w = PulseMeter::Visualize::DSL::Widget.new(type, widget_name)
+      add_widget_settings(w)
+      h[type] = w.to_widget
+    end
+  end
+
+  describe "#data" do
+    it "should contain type, title, interval, values_label, width, show_last_point attriutes" do
+      widgets.each do |k,w|
+        wdata = w.data
+        wdata[:type].should == k
+        wdata[:title].should == widget_name
+        wdata[:interval].should == redraw_interval
+        wdata[:values_title].should == values_label
+        wdata[:width].should == width
+      end
+    end
+
+    describe "series attribute" do
+      before(:each) do
+        Timecop.freeze(interval_start + 1) do
+          a_sensor.event(12)
+          b_sensor.event(33)
+        end
+        Timecop.freeze(interval_start + interval + 1) do
+          a_sensor.event(111)
+        end
+        @current_time = interval_start + 2 * interval - 1
+
+      end
+      context "pie widget" do
+
+        it "should contain valid pie series" do
+
+          Timecop.freeze(@current_time) do
+            widgets[:pie].data[:series].should == [{
+              type: :pie,
+              name: values_label,
+              data: [{
+                name: a_sensor.annotation,
+                color: a_color,
+                y: 12
+              }, {
+                name: b_sensor.annotation,
+                color: b_color,
+                y: 33
+              }]
+
+            }]
+          end
+
+        end
+
+        context "line, spline, area widgets" do
+
+          it "should contain valid series" do
+
+            Timecop.freeze(@current_time) do
+
+              [:line, :spline, :area].each do |type|
+
+                widget = widgets[type]
+                widget.data[:series].should == [{
+                  name: a_sensor.annotation,
+                  color: a_color,
+                  data: [{x: interval_start.to_i * 1000, y: 12}]
+                }, {
+                  name: b_sensor.annotation,
+                  color: b_color,
+                  data: [{x: interval_start.to_i * 1000, y: 33}]
+                }]
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/pulse_meter/visualizer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe PulseMeter::Visualizer do
+  describe "::draw" do
+    it "should generate correct layout with passed block" do
+      layout = described_class.draw do |l|
+
+        l.title "My Gauges"
+
+        l.page "Dashboard" do |p|
+          p.spline :convertion do |c|
+            c.sensor :adv_clicks, color: :green
+            c.sensor :adv_shows, color: :red
+          end
+
+          p.pie :agents, title: 'User Agents' do |c|
+            c.sensor :agent_ie
+            c.sensor :agent_chrome
+            c.sensor :agent_ff
+            c.sensor :agent_other
+          end
+
+        end
+
+        l.page "Request stats" do |p|
+          p.spline :rph_total, sensor: :rph_total
+          p.line :rph_main_page, sensor: :rph_main_page
+          p.line :request_time_p95_hour
+        
+          p.pie :success_vs_fail_total_hourly do |w|
+            w.sensor :success_total_hourly
+            w.sensor :fail_total_hourly
+          end
+
+        end
+
+      end
+      layout.should be_kind_of(PulseMeter::Visualize::Layout)
+    end
+  end
+end
+

data/spec/pulse_meter_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe PulseMeter do
+  describe "::redis=" do
+    it "should store redis" do
+      PulseMeter.redis = 'redis'
+      PulseMeter.redis.should == 'redis'
+    end
+  end
+  describe "::redis" do
+    it "should retrieve redis" do
+      PulseMeter.redis = 'redis'
+      PulseMeter.redis.should == 'redis'
+    end
+  end
+end

data/spec/shared_examples/timeline_sensor.rb

@@ -0,0 +1,279 @@
+shared_examples_for "timeline sensor" do |extra_init_values, default_event|
+  class Dummy
+    include PulseMeter::Mixins::Dumper
+    def name; :dummy end
+    def redis; PulseMeter.redis; end
+  end
+
+  let(:name){ :some_value_with_history }
+  let(:ttl){ 100 }
+  let(:raw_data_ttl){ 30 }
+  let(:interval){ 5 }
+  let(:reduce_delay){ 3 }
+  let(:good_init_values){ {:ttl => ttl, :raw_data_ttl => raw_data_ttl, :interval => interval, :reduce_delay => reduce_delay}.merge(extra_init_values || {}) }
+  let!(:sensor){ described_class.new(name, good_init_values) }
+  let(:dummy) {Dummy.new}
+  let(:base_class){ PulseMeter::Sensor::Base }
+  let(:redis){ PulseMeter.redis }
+  let(:sample_event) {default_event || 123}
+
+  before(:each) do
+    @interval_id = (Time.now.to_i / interval) * interval
+    @raw_data_key = sensor.raw_data_key(@interval_id)
+    @next_raw_data_key = sensor.raw_data_key(@interval_id + interval)
+    @start_of_interval = Time.at(@interval_id)
+  end
+
+  describe "#dump" do
+    it "should be dumped succesfully" do
+      expect {sensor.dump!}.not_to raise_exception
+    end
+  end
+
+  describe ".restore" do
+    before do
+      # no need to call sensor.dump! explicitly for it
+      # will be called automatically after creation
+      @restored = base_class.restore(sensor.name)
+    end
+
+    it "should restore #{described_class} instance" do
+      @restored.should be_instance_of(described_class)
+    end
+
+    it "should restore object with the same data" do
+      def inner_data(obj)
+        obj.instance_variables.sort.map {|v| obj.instance_variable_get(v)}
+      end
+
+      inner_data(sensor).should == inner_data(@restored)
+    end
+  end
+
+  describe "#event" do
+    it "should write events to redis" do
+      expect{
+          sensor.event(sample_event)
+      }.to change{ redis.keys('*').count }.by(1)
+    end
+
+    it "should write data so that it totally expires after :raw_data_ttl" do
+      key_count = redis.keys('*').count
+      sensor.event(sample_event)
+      Timecop.freeze(Time.now + raw_data_ttl + 1) do
+        redis.keys('*').count.should == key_count
+      end
+    end
+
+    it "should write data to bucket indicated by truncated timestamp" do
+      key = sensor.raw_data_key(@interval_id)
+      expect{
+        Timecop.freeze(@start_of_interval) do
+          sensor.event(sample_event)
+        end
+      }.to change{ redis.ttl(key) }
+    end
+  end
+
+  describe "#summarize" do
+    it "should convert data stored by raw_data_key to a value defined only by stored data" do
+      Timecop.freeze(@start_of_interval) do
+        sensor.event(sample_event)
+      end
+      Timecop.freeze(@start_of_interval + interval) do
+        sensor.event(sample_event)
+      end
+      sensor.summarize(@raw_data_key).should == sensor.summarize(@next_raw_data_key)
+      sensor.summarize(@raw_data_key).should_not be_nil
+    end
+  end
+
+  describe "#reduce" do
+    it "should store summarized value into data_key" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      val = sensor.summarize(@raw_data_key)
+      val.should_not be_nil
+      sensor.reduce(@interval_id)
+      redis.get(sensor.data_key(@interval_id)).should == val.to_s
+    end
+
+    it "should remove original raw_data_key" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      expect{
+        sensor.reduce(@interval_id)
+      }.to change{ redis.keys(sensor.raw_data_key(@interval_id)).count }.from(1).to(0)
+    end
+
+    it "should expire stored summarized data" do
+      Timecop.freeze(@start_of_interval) do
+        sensor.event(sample_event)
+        sensor.reduce(@interval_id)
+        redis.keys(sensor.data_key(@interval_id)).count.should == 1
+      end
+      Timecop.freeze(@start_of_interval + ttl + 1) do
+        redis.keys(sensor.data_key(@interval_id)).count.should == 0
+      end
+    end
+
+    it "should not store data if there is no corresponding raw data" do
+      Timecop.freeze(@start_of_interval) do
+        sensor.reduce(@interval_id)
+        redis.keys(sensor.data_key(@interval_id)).count.should == 0
+      end
+    end
+  end
+
+  describe "#reduce_all_raw" do
+    it "should reduce all data older than reduce_delay" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      val0 = sensor.summarize(@raw_data_key)
+      Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
+      val1 = sensor.summarize(@next_raw_data_key)
+      expect{
+        Timecop.freeze(@start_of_interval + interval + interval + reduce_delay + 1) { sensor.reduce_all_raw }
+      }.to change{ redis.keys(sensor.raw_data_key('*')).count }.from(2).to(0)
+
+      redis.get(sensor.data_key(@interval_id)).should == val0.to_s
+      redis.get(sensor.data_key(@interval_id + interval)).should == val1.to_s
+    end
+
+    it "should not reduce fresh data" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+
+      expect{
+        Timecop.freeze(@start_of_interval + interval + reduce_delay - 1) { sensor.reduce_all_raw }
+      }.not_to change{ redis.keys(sensor.raw_data_key('*')).count }
+
+      expect{
+        Timecop.freeze(@start_of_interval + interval + reduce_delay - 1) { sensor.reduce_all_raw }
+      }.not_to change{ redis.keys(sensor.data_key('*')).count }
+    end
+  end
+
+  describe ".reduce_all_raw" do
+    it "should silently skip objects without reduce logic" do
+      dummy.dump!
+      expect {described_class.reduce_all_raw}.not_to raise_exception
+    end
+
+    it "should send reduce_all_raw to all dumped objects" do
+      described_class.any_instance.should_receive(:reduce_all_raw)
+      described_class.reduce_all_raw
+    end
+  end
+
+  describe "#timeline_within" do
+    it "shoulde raise exception unless both arguments are Time objects" do
+      [:q, nil, -1].each do |bad_value|
+        expect{ sensor.timeline_within(Time.now, bad_value) }.to raise_exception(ArgumentError)
+        expect{ sensor.timeline_within(bad_value, Time.now) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    it "should return an array of SensorData objects corresponding to stored data for passed interval" do
+      sensor.event(sample_event)
+      now = Time.now
+      timeline = sensor.timeline_within(now - 1, now)
+      timeline.should be_kind_of(Array)
+      timeline.each{|i| i.should be_kind_of(SensorData) }
+    end
+
+    it "should return array of results containing as many results as there are sensor interval beginnings in the passed interval" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
+
+      future = @start_of_interval + 3600
+      Timecop.freeze(future) do
+        sensor.timeline_within(
+          Time.at(@start_of_interval + interval - 1),
+          Time.at(@start_of_interval + interval + 1)
+        ).size.should == 1
+
+        sensor.timeline_within(
+          Time.at(@start_of_interval - 1),
+          Time.at(@start_of_interval + interval + 1)
+        ).size.should == 2
+      end
+
+      Timecop.freeze(@start_of_interval + interval + 2) do
+        sensor.timeline_within(
+          Time.at(@start_of_interval + interval + 1),
+          Time.at(@start_of_interval + interval + 2)
+        ).size.should == 0
+      end
+    end
+  end
+
+  describe "#timeline" do
+    it "should raise exception if passed interval is not a positive integer" do
+      [:q, nil, -1].each do |bad_interval|
+        expect{ sensor.timeline(bad_interval) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    it "should request timeline within interval from given number of seconds ago till now" do
+      Timecop.freeze do
+        now = Time.now
+        ago = interval * 100
+        sensor.timeline(ago).should == sensor.timeline_within(now - ago, now)
+      end
+    end
+
+    it "should return array of results containing as many results as there are sensor interval beginnings in the passed interval" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
+
+      Timecop.freeze(@start_of_interval + interval + 1) do
+        sensor.timeline(2).size.should == 1
+      end
+      Timecop.freeze(@start_of_interval + interval + 2) do
+        sensor.timeline(1).size.should == 0
+      end
+      Timecop.freeze(@start_of_interval + interval + 1) do
+        sensor.timeline(2 + interval).size.should == 2
+      end
+    end
+  end
+
+  describe "SensorData value for an interval" do
+    def check_sensor_data(sensor, value)
+      data = sensor.timeline(2).first
+      data.value.should == value
+      data.start_time.to_i.should == @interval_id
+    end
+
+    it "should contain summarized value stored by data_key for reduced intervals" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      sensor.reduce(@interval_id)
+      Timecop.freeze(@start_of_interval + 1){
+        check_sensor_data(sensor, redis.get(sensor.data_key(@interval_id)))
+      }
+    end
+
+    it "should contain summarized value based on raw data for intervals not yet reduced" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      Timecop.freeze(@start_of_interval + 1){
+        check_sensor_data(sensor, sensor.summarize(@raw_data_key))
+      }
+    end
+
+    it "should contain nil for intervals without any data" do
+      Timecop.freeze(@start_of_interval + 1) {
+        check_sensor_data(sensor, nil)
+      }
+    end
+  end
+
+  describe "#cleanup" do
+    it "should remove all sensor data (raw data, reduced data, annotations) from redis" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      sensor.reduce(@interval_id)
+      Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
+      sensor.annotate("Fooo sensor")
+
+      sensor.cleanup
+      redis.keys('*').should be_empty
+    end
+  end
+
+end