rearview 1.1.2-jruby → 1.2.0-jruby

data/spec/lib/graphite/target_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Graphite::Target do
+end
+

data/spec/lib/rearview/configuration_spec.rb

@@ -9,65 +9,85 @@ describe Rearview::Configuration do
   let(:config) { Rearview::Configuration.new }
 
   context 'validation' do
-    it { should validate_presence_of(:graphite_url) }
-    it { should validate_presence_of(:pagerduty_url) }
     it { should validate_presence_of(:default_from) }
-    it { should validate_presence_of(:sandbox_dir) }
     it { should validate_presence_of(:sandbox_exec) }
     it { should validate_presence_of(:sandbox_timeout) }
     it { should validate_presence_of(:default_url_options) }
     it { should validate_presence_of(:authentication) }
     it { should validate_numericality_of(:sandbox_timeout).is_greater_than(4) }
-    it "should requre sandbox_dir to be a directory" do
-      config.sandbox_dir="/__not_likely__"
-      config.valid?
-      expect(config.errors[:sandbox_dir]).to include("is not a directory")
-      config.sandbox_dir = File.dirname(__FILE__)
-      config.valid?
-      expect(config.errors[:sandbox_dir]).to be_empty
+    context 'sandbox_dir' do
+      it { should validate_presence_of(:sandbox_dir) }
+      it "should be a directory" do
+        config.sandbox_dir="/__not_likely__"
+        config.valid?
+        expect(config.errors[:sandbox_dir]).to include("is not a directory")
+        config.sandbox_dir = File.dirname(__FILE__)
+        config.valid?
+        expect(config.errors[:sandbox_dir]).to be_empty
+      end
     end
-    it "should require graphite_url to be a url" do
-      response = stub(code: 200)
-      HTTParty.stubs(:get).returns(response)
-      config.graphite_url="ssh://fooblah"
-      config.valid?
-      expect(config.errors[:graphite_url]).to include("is not a valid URL")
-      config.graphite_url="fooblah"
-      config.valid?
-      expect(config.errors[:graphite_url]).to include("is not a valid URL")
-      config.graphite_url="http://fooblah.com"
-      config.valid?
-      expect(config.errors[:graphite_url]).to be_empty
+    context 'graphite_connection' do
+      it { should validate_presence_of(:graphite_connection) }
+      it "should require url option to be a valid url" do
+        config.graphite_connection = { url: 'ssh://fooblah' }
+        config.valid?
+        expect(config.errors[:graphite_connection]).to include("does not contain a valid URL")
+      end
+      it "should require url option to be present" do
+        config.graphite_connection = { url: nil }
+        config.valid?
+        expect(config.errors[:graphite_connection]).to include("graphite URL can't be blank")
+      end
+      pending do
+        it "should require url option to be reachable" do
+          config.graphite_connection = { url: 'http://graphite6.graphitehosting.com' }
+          config.valid?
+          mock_client = mock(:reachable? => false)
+          Graphite::Client.expects(:new).returns(mock_client)
+          expect(config.errors[:graphite_connection]).to include("graphite cannot be reached")
+        end
+      end
     end
-    it "should require pagerduty_url to be a url" do
-      config.pagerduty_url="ftp://fooblah"
-      config.valid?
-      expect(config.errors[:pagerduty_url]).to include("is not a valid URL")
-      config.pagerduty_url="HTTPS://fooblah"
-      config.valid?
-      expect(config.errors[:pagerduty_url]).to be_empty
+    context 'pagerduty_url' do
+      it { should validate_presence_of(:pagerduty_url) }
+      it "should require pagerduty_url to be a url" do
+        config.pagerduty_url="ftp://fooblah"
+        config.valid?
+        expect(config.errors[:pagerduty_url]).to include("is not a valid URL")
+        config.pagerduty_url="HTTPS://fooblah"
+        config.valid?
+        expect(config.errors[:pagerduty_url]).to be_empty
+      end
     end
-    it "should require graphite_url to be reachable" do
-      response = stub(code: 400)
-      HTTParty.expects(:get).with("http://graphite.mycompany-unreachable.com").returns(response)
-      config.graphite_url="http://graphite.mycompany-unreachable.com"
-      config.valid?
-      expect(config.errors[:graphite_url]).to include("is not a reachable URL")
-      response = stub(code: 200)
-      HTTParty.expects(:get).with("http://graphite.mycompany.com").returns(response)
-      config.graphite_url="http://graphite.mycompany.com"
-      config.valid?
-      expect(config.errors[:graphite_url]).to be_empty
+    context 'statsd_connection' do
+      it "should be present if stats are enabled" do
+        config.enable_stats = false
+        config.valid?
+        expect(config.errors[:statsd_connection]).to be_empty
+        config.enable_stats = true
+        config.valid?
+        expect(config.errors[:statsd_connection]).to include("can't be blank")
+      end
     end
-    it "should require statsd_connection to be present if stats are enabled" do
-      config.enable_stats = false
-      config.valid?
-      expect(config.errors[:statsd_connection]).to be_empty
-      config.enable_stats = true
-      config.valid?
-      expect(config.errors[:statsd_connection]).to include("can't be blank")
+    context 'metrics_validator_schedule' do
+      it { 
+        Rearview::Configuration.any_instance.stubs(:metrics_validator_enabled?).returns(true)
+        should_not allow_value('abc').for(:metrics_validator_schedule) 
+      }
+      it { 
+        Rearview::Configuration.any_instance.stubs(:metrics_validator_enabled?).returns(true)
+        should allow_value('0 * * * * ?').for(:metrics_validator_schedule) 
+      }
+      it "should be present if metrics_validator is enabled" do
+        config.enable_metrics_validator = false
+        config.valid?
+        expect(config.errors[:metrics_validator_schedule]).to be_empty
+        config.enable_metrics_validator = true
+        config.metrics_validator_schedule = nil
+        config.valid?
+        expect(config.errors[:metrics_validator_schedule]).to include("can't be blank")
+      end
     end
-    pending "should require sanbox_exec to be executable"
   end
 
   context '.new' do
@@ -80,6 +100,7 @@ describe Rearview::Configuration do
       expect(config.enable_monitor).to be_true
       expect(config.enable_stats).to be_false
       expect(config.verify).to be_false
+      expect(config.graphite_connection).to eq({})
       expect(config.authentication).to eq({strategy: :database})
       expect(config.default_url_options).to eq({:host=>"localhost", :port=>"3000"})
     end

data/spec/lib/rearview/metrics_validator_service_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Rearview::MetricsValidatorService do
+  before do
+    Celluloid.shutdown
+    Celluloid.boot
+    @service = Rearview::MetricsValidatorService.new
+  end
+  context '#startup' do
+    it "can only be started if stopped" do
+      Rearview::MetricsValidatorTask.stubs(:supervise).returns(mock)
+      @service.startup
+      expect { @service.startup }.to raise_error("service already started")
+    end
+    it "should create the supervised task" do
+      Rearview::MetricsValidatorTask.expects(:supervise)
+      @service.startup
+    end
+  end
+  context '#shutdown' do
+    it "can only be shutdown if started" do
+      expect { @service.shutdown }.to raise_error("service not started")
+    end
+    it "should terminate the supervised task" do
+      mock_task = mock
+      mock_task.expects(:terminate).once
+      Rearview::MetricsValidatorTask.stubs(:supervise).returns(stub(:actors => stub(:first => mock_task)))
+      @service.startup
+      @service.shutdown
+    end
+  end
+  context '#started?' do
+    it "should be true if the service is started" do
+      Rearview::MetricsValidatorTask.stubs(:supervise).returns(mock)
+      @service.startup
+      expect(@service.started?).to be_true
+    end
+    it "should be false if the service is not started" do
+      expect(@service.started?).to be_false
+    end
+  end
+end
+

data/spec/lib/rearview/metrics_validator_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Rearview::MetricsValidator do
+
+  context '#metric_valid?' do
+    let(:metrics_validator) { Rearview::MetricsValidator.new({ attributes: [:metrics] })}
+    context 'true' do
+      it 'when the metric is commented out' do
+        expect(metrics_validator.metric_valid?('#stats_count.foo')).to be_true
+      end
+      it 'when the metric is complex' do
+        mock_client = mock(:metric_exists? => true)
+        metrics_validator.stubs(:client).returns(mock_client)
+        expect(metrics_validator.metric_valid?(%q[alias(summarize(stats_counts.watson.summary_tables.run,"5min"),"Daily Watson Tables so far")])).to be_true
+      end
+    end
+    context 'false' do
+      it 'when the metric is not parseable' do
+        expect(metrics_validator.metric_valid?(%q[alias@(stats.x.y,"processed")])).to be_false
+      end
+      it 'when the metric cannot be extracted' do
+        mock_parser = mock
+        mock_parser.stubs(:parse)
+        mock_parser.stubs(:error?).returns(false)
+        mock_parser.stubs(:tree).returns(mock(:comment? => false,:metric => nil))
+        metrics_validator.stubs(:target_parser).returns(mock_parser)
+        expect(metrics_validator.metric_valid?('stats.garbage.ignored')).to be_false
+      end
+    end
+  end
+  context '#validate_each' do
+    let(:job) { FactoryGirl.create(:job) }
+    let(:metrics_validator) { Rearview::MetricsValidator.new({ attributes: [:metrics] })}
+    context 'valid' do
+      it 'parses the metric' do
+        mock_client = mock(:metric_exists? => true)
+        metrics_validator.stubs(:client).returns(mock_client)
+        expect(metrics_validator.metric_valid?(%q[alias(summarize(stats_counts.watson.summary_tables.run,"5min"),"Daily Watson Tables so far")])).to be_true
+      end
+      it 'when all metrics exists' do
+        mock_client = mock(:metric_exists? => true)
+        metrics_validator.stubs(:client).returns(mock_client)
+        metrics_validator.validate_each(job,:metrics,job.metrics)
+        expect(job.errors[:metrics]).to be_empty
+      end
+    end
+    context 'invalid' do
+      it 'when one metric does not exist' do
+        job.metrics << "metric.fooey"
+        mock_client = mock
+        mock_client.expects(:metric_exists?).with("metric.fooey").returns(false)
+        mock_client.expects(:metric_exists?).with(job.metrics.first).returns(true)
+        metrics_validator.stubs(:client).returns(mock_client)
+        metrics_validator.validate_each(job,:metrics,job.metrics)
+        expect(job.errors[:metrics]).to include("contains an invalid metric: metric.fooey")
+        expect(job.errors[:metrics]).not_to include("contains an invalid metric: #{job.metrics.first}")
+      end
+    end
+    context 'cache' do
+      context 'enabled' do
+        let(:caching_validator) { Rearview::MetricsValidator.new({ attributes: [:metrics], cache: true })}
+        it 'caches responses for metrics' do
+          job.metrics << job.metrics.first
+          mock_client = mock
+          mock_client.expects(:metric_exists?).with(job.metrics.first).once.returns(true)
+          caching_validator.stubs(:client).returns(mock_client)
+          caching_validator.validate_each(job,:metrics,job.metrics)
+          expect(job.errors[:metrics]).to be_empty
+        end
+      end
+      context 'disabled' do
+        it 'does not cache responses for metrics' do
+          job.metrics << job.metrics.first
+          mock_client = mock
+          mock_client.expects(:metric_exists?).with(job.metrics.first).twice.returns(true)
+          metrics_validator.stubs(:client).returns(mock_client)
+          metrics_validator.validate_each(job,:metrics,job.metrics)
+          expect(job.errors[:metrics]).to be_empty
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/rearview/metrics_validator_task_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Rearview::MetricsValidatorTask do
+
+  before do
+    now = Time.now
+    Timecop.freeze(Time.local(now.year,now.mon,now.day))
+  end
+
+  context '.initialize' do
+    it 'schedules itself by default' do
+      Rearview::MetricsValidatorTask.any_instance.expects(:schedule)
+      Rearview::MetricsValidatorTask.new('0 * * * * ?')
+    end
+  end
+
+  context '#schedule' do
+    it 'sets the delay to 60s if the cron expression is \'0 * * * * ?\'' do
+      task = Rearview::MetricsValidatorTask.new('0 * * * * ?',false)
+      task.expects(:after).with(60.0).once
+      task.schedule
+    end
+    it 'sets the delay to 300s if the cron expression is \'0 5 * * * ?\'' do
+      task = Rearview::MetricsValidatorTask.new('0 5 * * * ?',false)
+      task.expects(:after).with(300.0).once
+      task.schedule
+    end
+  end
+
+  context '.run' do
+    let(:job1_invalid) {
+      job = FactoryGirl.create(:job)
+      job.errors.add(:metrics,"contains an invalid metric: #{job.metrics.first}")
+      job
+    }
+    let(:job2_valid) {
+      FactoryGirl.create(:job)
+    }
+    let(:job3_invalid) {
+      job = FactoryGirl.create(:job)
+      job.errors.add(:metrics,"contains an invalid metric: #{job.metrics.first}")
+      job
+    }
+    it 'still schedules if there is an exception' do
+      Rearview::Job.stubs(:schedulable).raises(StandardError,"oops")
+      task = Rearview::MetricsValidatorTask.new('0 5 * * * ?',false)
+      task.expects(:schedule).once
+      task.run
+    end
+    it 'mails alerts only for jobs with invalid metrics' do
+      Rearview::Job.stubs(:schedulable).returns(mock(:load => [job1_invalid,job2_valid,job3_invalid]))
+      Rearview::MetricsValidator.any_instance.stubs(:validate_each)
+      task = Rearview::MetricsValidatorTask.new('0 5 * * * ?',false)
+      task.expects(:schedule).once
+      task.expects(:alert_validation_failed).with(job1_invalid).once
+      task.expects(:alert_validation_failed).with(job2_valid).never
+      task.expects(:alert_validation_failed).with(job3_invalid).once
+      task.run
+    end
+  end
+
+end

data/spec/lib/rearview/monitor_runner_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe Rearview::MonitorRunner, :travis=>true do
 
-  artifact1 = Rearview::GraphiteParser.parse open("spec/data/monitor.dat").read
-  artifact2 = Rearview::GraphiteParser.parse open("spec/data/test.dat").read
-  artifact3 = Rearview::GraphiteParser.parse open("spec/data/large_set.dat").read
+  artifact1 = Graphite::RawParser.parse open("spec/data/monitor.dat").read
+  artifact2 = Graphite::RawParser.parse open("spec/data/test.dat").read
+  artifact3 = Graphite::RawParser.parse open("spec/data/large_set.dat").read
 
   context 'create_from_to_dates' do
     before do

data/spec/lib/rearview/stats_task_spec.rb

@@ -39,6 +39,27 @@ describe Rearview::StatsTask do
       stats_task.statsd.expects(:batch)
       stats_task.run
     end
+    it "sends the correct stats" do
+      statsd = mock
+      batch = mock
+      statsd.expects(:batch_size=)
+      Rearview::Statsd.stubs(:new).returns(statsd)
+      stats_task = Rearview::StatsTask.new(120,false)
+      statsd.expects(:batch).yields(batch)
+      batch.expects(:gauge).with('vm.total_memory',any_parameters)
+      batch.expects(:gauge).with('vm.free_memory',any_parameters)
+      batch.expects(:gauge).with('vm.max_memory',any_parameters)
+      batch.expects(:gauge).with('vm.heap.committed',any_parameters)
+      batch.expects(:gauge).with('vm.heap.init',any_parameters)
+      batch.expects(:gauge).with('vm.heap.max',any_parameters)
+      batch.expects(:gauge).with('vm.heap.used',any_parameters)
+      batch.expects(:gauge).with('vm.non_heap.committed',any_parameters)
+      batch.expects(:gauge).with('vm.non_heap.init',any_parameters)
+      batch.expects(:gauge).with('vm.non_heap.max',any_parameters)
+      batch.expects(:gauge).with('vm.non_heap.used',any_parameters)
+      batch.expects(:gauge).with('monitor.total',any_parameters)
+      stats_task.run
+    end
   end
 
 end

data/spec/mailers/metrics_validation_mailer_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Rearview::MetricsValidationMailer do
+
+  let(:job) {
+    job = FactoryGirl.build(:job)
+    job.errors.add(:metrics,"contains an invalid metric: stats.my_count")
+    job
+  }
+
+  let(:mail) {
+    Rearview::MetricsValidationMailer.validation_failed_email("foo@foo.com",job)
+  }
+
+  context 'subject' do
+    it 'contains the job name' do
+      expect(mail.subject).to match(/#{job.name}/)
+    end
+    it 'contains subject tag' do
+      expect(mail.subject).to match(/\[Rearview ALERT\]/)
+    end
+  end
+
+  context 'body' do
+    it 'has the alert message' do
+      expect(mail.body.encoded).to match(/ALERT: Job has \(1\) invalid metric/)
+    end
+    it 'has the monitor name' do
+      expect(mail.body.encoded).to match(/Monitor: #{job.name}/)
+    end
+    it 'has the monitor description' do
+      expect(mail.body.encoded).to match(/Description: #{job.description}/)
+    end
+    it 'has the alerted on date' do
+      expect(mail.body.encoded).to match(/Alerted On: .*/)
+    end
+    it 'has a direct link' do
+      expect(mail.body.encoded).to match(%r{Direct Link: http://localhost:3000/rearview/#dash/#{job.app_id}/expand/#{job.id}})
+    end
+    it 'has the invalid metric name' do
+      expect(mail.body.encoded).to match(/^stats.my_count/)
+    end
+  end
+
+end
+

data/spec/models/job_spec.rb

@@ -10,26 +10,39 @@ describe Rearview::Job do
   end
 
   describe 'validations' do
-    it { should validate_presence_of(:cron_expr) }
     it { should validate_presence_of(:name) }
     it { should validate_presence_of(:metrics) }
     it { should validate_presence_of(:app_id) }
-    it { should_not allow_value('abc').for(:cron_expr) }
-    it { should allow_value('0 * * * * ?').for(:cron_expr) }
     it { should ensure_inclusion_of(:status).in_array(Rearview::Job::Status.values) }
+    describe 'cron_expr' do
+      before do
+        Rearview::MetricsValidator.any_instance.stubs(:validate_each)
+        Rearview::Job.any_instance.stubs(:deep_validation?).returns(true)
+      end
+      it { should validate_presence_of(:cron_expr) }
+      it { should_not allow_value('abc').for(:cron_expr) }
+      it { should allow_value('0 * * * * ?').for(:cron_expr) }
+    end
     describe 'alert_keys' do
-      let(:job) { create(:job) }
+      before do
+        Rearview::MetricsValidator.any_instance.stubs(:validate_each)
+      end
+      let(:job) {
+        job = create(:job)
+        job.deep_validation = true
+        job
+      }
       it "should require a valid URI" do
         keys = ["htptptptpt://not_a_uri"]
         job.alert_keys=keys
         expect(job.valid?).to be_false
-        expect(job.errors[:alert_keys]).to include("invalid URI")
+        expect(job.errors[:alert_keys]).to include("#{keys.first} is an invalid URI")
       end
       it "should require it to be one of the supported schemes" do
         keys = ["http://www.google.com"]
         job.alert_keys=keys
         expect(job.valid?).to be_false
-        expect(job.errors[:alert_keys]).to include("unsupported scheme")
+        expect(job.errors[:alert_keys]).to include("#{keys.first} is not a supported alert type")
       end
       it "should validate the scheme against the corresponding alert" do
         keys = ["pagerduty:10101010101010101010101010101010","mailto:first.last@hungrymachine.com","campfire://first.last@hungrymachine.com?token=123&room=text"]
@@ -40,19 +53,19 @@ describe Rearview::Job do
         keys = ["pagerduty:abcdefg"]
         job.alert_keys=keys
         expect(job.valid?).to be_false
-        expect(job.errors[:alert_keys]).to include("pagerduty URI is invalid")
+        expect(job.errors[:alert_keys]).to include("#{keys.first} is invalid for supported alert type")
       end
       it "should detect an invalid mail URI" do
         keys = ["mailto:abcdefg"]
         job.alert_keys=keys
         expect(job.valid?).to be_false
-        expect(job.errors[:alert_keys]).to include("mailto URI is invalid")
+        expect(job.errors[:alert_keys]).to include("#{keys.first} is invalid for supported alert type")
       end
       it "should detect an invalid campfire URI" do
         keys = ["campfire://first.last@hungrymachine.com"]
         job.alert_keys=keys
         expect(job.valid?).to be_false
-        expect(job.errors[:alert_keys]).to include("campfire URI is invalid")
+        expect(job.errors[:alert_keys]).to include("#{keys.first} is invalid for supported alert type")
       end
     end
   end
@@ -133,13 +146,73 @@ describe Rearview::Job do
       inactive_job.sync_monitor_service
     end
   end
+  describe '#set_defaults' do
+    context 'alert_keys' do
+      it "should set it to an empty array if not present" do
+        job = create(:job, { alert_keys: nil})
+        job.save!
+        expect(job.alert_keys).to eq([])
+        job = create(:job)
+        expect(job.alert_keys).not_to eq([])
+      end
+    end
+  end
+  describe '#delay' do
+    before do
+      now = Time.now
+      Timecop.freeze(Time.local(now.year,now.mon,now.day))
+    end
+    after do
+      Timecop.return
+    end
+    it "cron expression '0 * * * * ?' to be 60.0" do
+      job = build(:job,cron_expr: '0 * * * * ?')
+      expect(job.delay).to eq(60.0)
+    end
+    it "any cron expression other than '0 * * * * ?' to be calculated by Rearview::CronHelper" do
+      job = build(:job,cron_expr: '0 30 * * * ?')
+      Rearview::CronHelper.expects(:next_valid_time_after).with('0 30 * * * ?')
+      job.delay
+    end
+  end
+  describe '#translate_associated_event' do
+    let(:transition) { mock }
+    let(:job) { create(:job) }
+    it 'echos back any non-security error' do
+      transition.stubs(:event).returns(:foo)
+      expect(job.send(:translate_associated_event,transition)).to eq(:foo)
+    end
+    it 'translates it to an :error' do
+      transition.stubs(:event).returns(:security_error)
+      expect(job.send(:translate_associated_event,transition)).to eq(:error)
+    end
+  end
   describe '#report_transition' do
+    let(:transition) { mock }
+    let(:job) { create(:job) }
+    before do
+      @statsd = mock
+      Rearview.config.stubs(:stats_enabled?).returns(true)
+      Rearview::Statsd.stubs(:statsd).returns(@statsd)
+    end
     context 'success event' do
       it "should increment monitor.success" do
+        transition.stubs(:event).returns(:success)
+        @statsd.expects(:increment).with("monitor.success") 
+        job.send(:report_transition,transition)
       end
     end
     context 'failure event' do
       it "should increment monitor.failure" do
+        transition.stubs(:event).returns(:error)
+        @statsd.expects(:increment).with("monitor.failure") 
+        job.send(:report_transition,transition)
+      end
+    end
+    context 'exception' do
+      it "should not raise" do
+        transition.stubs(:event).raises
+        expect{job.send(:report_transition,transition)}.not_to raise_error
       end
     end
   end