appsignal 0.6.7 → 0.7.0.alpha.1

data/spec/{appsignal → lib/appsignal}/agent_spec.rb

@@ -4,8 +4,76 @@ class PostProcessingException < Exception
 end
 
 describe Appsignal::Agent do
+  before :all do
+    start_agent
+  end
+
   let(:transaction) { regular_transaction }
 
+  describe "#sleep_time" do
+    subject { Appsignal::Agent.new.sleep_time }
+
+    it { should == 60 }
+
+    context "for development" do
+      before do
+        Appsignal.config.stub(:env => 'development')
+      end
+
+      it { should == 10 }
+    end
+  end
+
+  describe "#start_thread" do
+    it "should have started a background thread" do
+      subject.thread.should be_a(Thread)
+    end
+  end
+
+  describe "#subscribe" do
+    it "should have set the appsignal subscriber" do
+      if defined? ActiveSupport::Notifications::Fanout::Subscribers::Timed
+        # ActiveSupport 4
+        subject.subscriber.should be_a ActiveSupport::Notifications::Fanout::Subscribers::Timed
+      else
+        # ActiveSupport 3
+        subject.subscriber.should be_a ActiveSupport::Notifications::Fanout::Subscriber
+      end
+    end
+
+    context "handling events" do
+      before do
+        Appsignal::Transaction.create('123', {})
+      end
+
+      it "should should not listen to events that start with a bang" do
+        Appsignal::Transaction.current.should_not receive(:add_event)
+
+        ActiveSupport::Notifications.instrument '!render_template'
+      end
+
+      it "should add a normal event" do
+        Appsignal::Transaction.current.should_not receive(:set_process_action_event)
+        Appsignal::Transaction.current.should receive(:add_event).with(
+          kind_of(ActiveSupport::Notifications::Event)
+        ).at_least(:once)
+
+        ActiveSupport::Notifications.instrument 'render_template'
+      end
+
+      it "should add and set a process action event" do
+        Appsignal::Transaction.current.should receive(:set_process_action_event).with(
+          kind_of(ActiveSupport::Notifications::Event)
+        ).at_least(:once)
+        Appsignal::Transaction.current.should receive(:add_event).with(
+          kind_of(ActiveSupport::Notifications::Event)
+        ).at_least(:once)
+
+        ActiveSupport::Notifications.instrument 'process_action.rack'
+      end
+    end
+  end
+
   describe "#enqueue" do
     it "forwards to the aggregator" do
       subject.aggregator.should respond_to(:add)
@@ -57,7 +125,7 @@ describe Appsignal::Agent do
 
   describe "#shutdown" do
     before do
-      ActiveSupport::Notifications.should_receive(:unsubscribe).with(Appsignal.subscriber)
+      ActiveSupport::Notifications.should_receive(:unsubscribe).with(subject.subscriber)
       Thread.should_receive(:kill).with(subject.thread)
     end
 

data/spec/lib/appsignal/aggregator/middleware/action_view_sanitizer_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+if rails_present?
+  require 'action_view'
+  require 'appsignal/aggregator/middleware/action_view_sanitizer'
+
+  describe Appsignal::Aggregator::Middleware::ActionViewSanitizer do
+    let(:klass) { Appsignal::Aggregator::Middleware::ActionViewSanitizer }
+    let(:sanitizer) { klass.new }
+
+    describe "#call" do
+      before { Rails.root.stub(:to_s => '/var/www/app/20130101') }
+      let(:event) do
+        notification_event(
+          :name => 'render_partial.action_view',
+          :payload => create_payload(payload)
+        )
+      end
+      let(:payload) do
+        {
+          :identifier => '/var/www/app/20130101/app/views/home/index/html.erb'
+        }
+      end
+      subject { event.payload }
+      before { sanitizer.call(event) { } }
+
+      it "should strip Rails root from the path" do
+        payload[:identifier].should == 'app/views/home/index/html.erb'
+      end
+    end
+  end
+end

data/spec/lib/appsignal/aggregator/middleware/active_record_sanitizer_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+if rails_present?
+  require 'active_record'
+  require 'appsignal/aggregator/middleware/active_record_sanitizer'
+
+  describe Appsignal::Aggregator::Middleware::ActiveRecordSanitizer do
+    let(:klass) { Appsignal::Aggregator::Middleware::ActiveRecordSanitizer }
+    let(:sql_event_sanitizer) { klass.new }
+    let(:connection_config) { {} }
+    before do
+      if ActiveRecord::Base.respond_to?(:connection_config)
+        # Rails 3.1+
+        ActiveRecord::Base.stub(
+          :connection_config => connection_config
+        )
+      else
+        # Rails 3.0
+        spec = double(:config => connection_config)
+        ActiveRecord::Base.stub(
+          :connection_pool => double(:spec => spec)
+        )
+      end
+    end
+
+    describe "#call" do
+      let(:name) { 'Model load' }
+      let(:binds) { [] }
+      let(:event) do
+        notification_event(
+          :name => 'sql.active_record',
+          :payload => create_payload(
+            :name => name,
+            :sql => sql,
+            :binds => binds,
+            :connection_id => 1111
+          )
+        )
+      end
+      subject { event.payload[:sql] }
+      before { sql_event_sanitizer.call(event) { } }
+
+      context "connection id and bindings" do
+        let(:sql) { '' }
+        subject { event.payload }
+
+        it { should_not have_key(:connection_id) }
+        it { should_not have_key(:binds) }
+      end
+
+      context "with backtick table names" do
+        before { sql_event_sanitizer.stub(:adapter_uses_double_quoted_table_names? => false) }
+
+        context "single quoted data value" do
+          let(:sql) { "SELECT `table`.* FROM `table` WHERE `id` = 'secret'" }
+
+          it { should == "SELECT `table`.* FROM `table` WHERE `id` = ?" }
+
+          context "with an escaped single quote" do
+            let(:sql) { "`id` = '\\'big\\' secret'" }
+
+            it { should == "`id` = ?" }
+          end
+
+          context "with an escaped double quote" do
+            let(:sql) { "`id` = '\\\"big\\\" secret'" }
+
+            it { should == "`id` = ?" }
+          end
+        end
+
+        context "double quoted data value" do
+          let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` = "secret"' }
+
+          it { should == 'SELECT `table`.* FROM `table` WHERE `id` = ?' }
+
+          context "with an escaped single quote" do
+            let(:sql) { '`id` = "\\\'big\\\' secret"' }
+
+            it { should == "`id` = ?" }
+          end
+
+          context "with an escaped double quote" do
+            let(:sql) { '`id` = "\\"big\\" secret"' }
+
+            it { should == "`id` = ?" }
+          end
+        end
+
+        context "numeric parameter" do
+          let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` = 1' }
+
+          it { should == 'SELECT `table`.* FROM `table` WHERE `id` = ?' }
+        end
+
+        context "parameter array" do
+          let(:sql) { 'SELECT `table`.* FROM `table` WHERE `id` IN (1, 2)' }
+
+          it { should == 'SELECT `table`.* FROM `table` WHERE `id` IN (?)' }
+        end
+      end
+
+      context "with double quote style table names and no prepared statements" do
+        let(:connection_config) { {:adapter => 'postgresql', :prepared_statements => false} }
+
+        context "single quoted data value" do
+          let(:sql) { "SELECT \"table\".* FROM \"table\" WHERE \"id\" = 'secret'" }
+
+          it { should == "SELECT \"table\".* FROM \"table\" WHERE \"id\" = ?" }
+
+          context "with an escaped single quote" do
+            let(:sql) { "\"id\" = '\\'big\\' secret'" }
+
+            it { should == "\"id\" = ?" }
+          end
+
+          context "with an escaped double quote" do
+            let(:sql) { "\"id\" = '\\\"big\\\" secret'" }
+
+            it { should == "\"id\" = ?" }
+          end
+        end
+
+        context "numeric parameter" do
+          let(:sql) { 'SELECT "table".* FROM "table" WHERE "id"=1' }
+
+          it { should == 'SELECT "table".* FROM "table" WHERE "id"=?' }
+        end
+      end
+
+      context "skip sanitization for prepared statements" do
+        let(:connection_config) { {:adapter => 'postgresql'} }
+
+        let(:sql) { 'SELECT "table".* FROM "table" WHERE "id"=$1' }
+
+        it { should == 'SELECT "table".* FROM "table" WHERE "id"=$1' }
+      end
+
+      context "skip sanitization for schema queries" do
+        let(:name) { 'SCHEMA' }
+        let(:sql) { 'SET client_min_messages TO 22' }
+
+        it { should == 'SET client_min_messages TO 22' }
+      end
+    end
+
+    describe "#schema_query?" do
+      let(:payload) { {} }
+      let(:event) { notification_event(:payload => payload) }
+      subject { sql_event_sanitizer.schema_query?(event) }
+
+      it { should be_false }
+
+      context "when name is schema" do
+        let(:payload) { {:name => 'SCHEMA'} }
+
+        it { should be_true }
+      end
+    end
+
+    context "connection config" do
+      describe "#connection_config" do
+        let(:connection_config) { {:adapter => 'adapter'} }
+
+        subject { sql_event_sanitizer.connection_config }
+
+        it { should == {:adapter => 'adapter'} }
+      end
+
+      describe "#adapter_uses_double_quoted_table_names?" do
+        subject { sql_event_sanitizer.adapter_uses_double_quoted_table_names? }
+
+        context "when using mysql" do
+          let(:connection_config) { {:adapter => 'mysql'} }
+
+          it { should be_false }
+        end
+
+        context "when using postgresql" do
+          let(:connection_config) { {:adapter => 'postgresql'} }
+
+          it { should be_true }
+        end
+
+        context "when using sqlite" do
+          let(:connection_config) { {:adapter => 'sqlite'} }
+
+          it { should be_true }
+        end
+      end
+
+      describe "adapter_uses_prepared_statements?" do
+        subject { sql_event_sanitizer.adapter_uses_prepared_statements? }
+
+        context "when using mysql" do
+          let(:connection_config) { {:adapter => 'mysql'} }
+
+          it { should be_false }
+        end
+
+        context "when using postgresql" do
+          let(:connection_config) { {:adapter => 'postgresql'} }
+
+          it { should be_true }
+        end
+
+        context "when using postgresql and prepared statements is disabled" do
+          let(:connection_config) { {:adapter => 'postgresql', :prepared_statements => false} }
+
+          it { should be_false }
+        end
+      end
+    end
+  end
+end

data/spec/{appsignal → lib/appsignal/aggregator}/middleware/chain_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe Appsignal::Middleware do
-  let(:chain_klass) { Appsignal::Middleware::Chain }
-  let(:entry_klass) { Appsignal::Middleware::Entry }
+describe Appsignal::Aggregator::Middleware do
+  let(:chain_klass) { Appsignal::Aggregator::Middleware::Chain }
+  let(:entry_klass) { Appsignal::Aggregator::Middleware::Entry }
   let(:chain) { chain_klass.new }
   let(:entry) { entry_klass.new(object, {:foo => :bar}) }
 
-  describe Appsignal::Middleware::Chain do
+  describe Appsignal::Aggregator::Middleware::Chain do
     let(:object) { double(:object) }
     let(:other_object) { double(:other_object) }
 
@@ -153,7 +153,7 @@ describe Appsignal::Middleware do
     end
   end
 
-  describe Appsignal::Middleware::Entry do
+  describe Appsignal::Aggregator::Middleware::Entry do
 
     describe "#make_new" do
       let(:object) { double }

data/spec/{appsignal → lib/appsignal/aggregator}/middleware/delete_blanks_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Appsignal::Middleware::DeleteBlanks do
-  let(:klass) { Appsignal::Middleware::DeleteBlanks }
+describe Appsignal::Aggregator::Middleware::DeleteBlanks do
+  let(:klass) { Appsignal::Aggregator::Middleware::DeleteBlanks }
   let(:delete_blanks) { klass.new }
 
   describe "#call" do

data/spec/{appsignal → lib/appsignal}/aggregator/post_processor_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
-describe Appsignal::PostProcessor do
-  let(:klass) { Appsignal::PostProcessor }
+describe Appsignal::Aggregator::PostProcessor do
+  before :all do
+    start_agent
+  end
+
+  let(:klass) { Appsignal::Aggregator::PostProcessor }
   let(:post_processor) { klass.new(transactions) }
 
   describe "#initialize" do
@@ -73,12 +77,17 @@ describe Appsignal::PostProcessor do
   describe ".default_middleware" do
     subject { klass.default_middleware }
 
-    it { should be_instance_of Appsignal::Middleware::Chain }
+    it { should be_instance_of Appsignal::Aggregator::Middleware::Chain }
 
     it "should include the default middleware stack" do
-      subject.exists?(Appsignal::Middleware::DeleteBlanks).should be_true
-      subject.exists?(Appsignal::Middleware::ActionViewSanitizer).should be_true
-      subject.exists?(Appsignal::Middleware::ActiveRecordSanitizer).should be_true
+      subject.exists?(Appsignal::Aggregator::Middleware::DeleteBlanks).should be_true
+      if rails_present?
+        subject.exists?(Appsignal::Aggregator::Middleware::ActionViewSanitizer).should be_true
+        subject.exists?(Appsignal::Aggregator::Middleware::ActiveRecordSanitizer).should be_true
+      else
+        subject.exists?(Appsignal::Aggregator::Middleware::ActionViewSanitizer).should be_false
+        subject.exists?(Appsignal::Aggregator::Middleware::ActiveRecordSanitizer).should be_false
+      end
     end
   end
 end

data/spec/{appsignal → lib/appsignal}/aggregator_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
 describe Appsignal::Aggregator do
+  before :all do
+    start_agent
+  end
+
   let(:aggregator) { Appsignal::Aggregator.new }
 
   describe "#add" do
@@ -178,5 +182,4 @@ describe Appsignal::Aggregator do
       end
     end
   end
-
 end

data/spec/{appsignal → lib/appsignal}/auth_check_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe Appsignal::AuthCheck do
-  let(:auth_check) { Appsignal::AuthCheck.new('production') }
+  let(:config) { project_fixture_config }
+  let(:logger) { Logger.new(StringIO.new) }
+  let(:auth_check) { Appsignal::AuthCheck.new(config, logger) }
 
   describe "#perform_with_result" do
     it "should give success message" do
@@ -16,7 +18,7 @@ describe Appsignal::AuthCheck do
         ['401', 'API key not valid with AppSignal...']
     end
 
-    it "should give error message" do
+    it "should give an error message" do
       auth_check.should_receive(:perform).and_return('402')
       auth_check.perform_with_result.should ==
         ['402', 'Could not confirm authorization: 402']
@@ -26,9 +28,10 @@ describe Appsignal::AuthCheck do
   context "transmitting" do
     before do
       @transmitter = double
-      Appsignal::Transmitter.should_receive(:new).
-        with('http://localhost:3000/1', 'auth', 'def').
-        and_return(@transmitter)
+      Appsignal::Transmitter.should_receive(:new).with(
+        'auth',
+        kind_of(Appsignal::Config)
+      ).and_return(@transmitter)
     end
 
     describe "#perform" do
@@ -37,23 +40,5 @@ describe Appsignal::AuthCheck do
         auth_check.perform
       end
     end
-
-    describe "#uri" do
-      before do
-        @transmitter.should_receive(:transmit)
-        auth_check.perform
-      end
-
-      it "should delegate to transmitter" do
-        @transmitter.should_receive(:uri)
-        auth_check.uri
-      end
-
-      it "should return uri" do
-        @transmitter.should_receive(:uri).
-          and_return('http://appsignal.com/1/auth')
-        auth_check.uri.should == 'http://appsignal.com/1/auth'
-      end
-    end
   end
 end