appsignal 0.4.7 → 0.5.0

data/spec/appsignal/aggregator_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe Appsignal::Aggregator do
+  let(:aggregator) { Appsignal::Aggregator.new }
+
+  describe "#add" do
+    subject { aggregator.add(transaction) }
+
+    context "adding a regular transaction" do
+      let(:transaction) { regular_transaction }
+
+      specify { transaction.should_receive(:truncate!) }
+    end
+
+    context "adding a slow transaction" do
+      let(:transaction) { slow_transaction }
+
+      specify {
+        aggregator.should_receive(:pre_process_slowness!).with(transaction)
+      }
+    end
+
+    context "adding a transaction with an exception" do
+      let(:transaction) { transaction_with_exception }
+
+      specify { transaction.should_receive(:convert_values_to_primitives!) }
+    end
+
+    after { subject }
+  end
+
+  describe "#has_transactions?" do
+    subject { aggregator.has_transactions? }
+
+    context "with an empty queue" do
+      it { should be_false }
+    end
+
+    context "with an non empty queue" do
+      before { aggregator.add(regular_transaction) }
+
+      it { should be_true }
+    end
+  end
+
+  describe "#post_processed_queue!" do
+    let(:transaction) { slow_transaction }
+    let(:other_transaction) { regular_transaction }
+    subject { aggregator.post_processed_queue! }
+    before do
+      aggregator.add(transaction)
+      aggregator.add(other_transaction)
+    end
+
+    it { should be_a Array }
+
+    it "calls to_hash on each transaction in the queue" do
+      transaction.should_receive(:to_hash)
+      other_transaction.should_receive(:to_hash)
+      subject
+    end
+  end
+
+  # protected
+
+  describe "#similar_slowest" do
+    subject { aggregator.send(:similar_slowest, transaction) }
+    before { aggregator.add(other_transaction) }
+
+    context "passing a transaction concerning a different action" do
+      let(:transaction) { slow_transaction }
+      let(:other_transaction) do
+        time = Time.parse('01-01-2001 10:01:00')
+        appsignal_transaction(
+          :process_action_event => notification_event(
+            :payload => create_payload(
+              :action => 'show',
+              :controller => 'SomeOtherController'
+            )
+          )
+        )
+      end
+
+      it { should be_nil }
+    end
+
+    context "passing concerning the same action" do
+      let(:transaction) { slow_transaction }
+      let(:other_transaction) { slower_transaction }
+
+      it { should == other_transaction }
+    end
+  end
+
+  describe "#pre_process_slowness!" do
+    subject { aggregator.send(:pre_process_slowness!, transaction) }
+
+    context "without a similar slow transaction" do
+      let(:transaction) { slow_transaction }
+
+      it "calls convert_values_to_primitives on transaction" do
+        transaction.should_receive(:convert_values_to_primitives!)
+        subject
+      end
+
+      it "indexes the slow transaction" do
+        expect { subject }.to change(aggregator, :slowness_index).
+          to({transaction.action => transaction})
+      end
+    end
+
+    context "with a non similar slow transaction" do
+      let(:transaction) { slow_transaction }
+      let(:other_transaction) do
+        time = Time.parse('01-01-2001 10:01:00')
+        appsignal_transaction(
+          :process_action_event => notification_event(
+            :action => 'foooo',
+            :start => time,
+            :ending => time + Appsignal.config[:slow_request_threshold] / 500.0
+          )
+        )
+      end
+
+      it "calls convert_values_to_primitives on transaction" do
+        transaction.should_receive(:convert_values_to_primitives!)
+        subject
+      end
+
+      it "indexes the slow transaction" do
+        expect { subject }.to change(aggregator, :slowness_index).to({
+          other_transaction.action => other_transaction,
+          transaction.action => transaction
+        })
+      end
+    end
+
+    context "with a similar but slower transaction" do
+      let(:transaction) { slow_transaction }
+      let(:slower) { slower_transaction }
+      before { aggregator.add(slower) }
+
+      it "calls truncate on the transaction" do
+        transaction.should_receive(:truncate!)
+        transaction.should_not_receive(:convert_values_to_primitives!)
+        subject
+      end
+
+      it "does not index the slow transaction" do
+        expect { subject }.to_not change(aggregator, :slowness_index)
+      end
+
+      it "does not modify the slow transaction" do
+        slower.should_not_receive(:truncate!)
+        slower.should_not_receive(:convert_values_to_primitives!)
+        subject
+      end
+    end
+
+    context "with a similar but faster transaction" do
+      let(:transaction) { slower_transaction }
+      let(:faster_transaction) { slow_transaction }
+      before { aggregator.add(faster_transaction) }
+
+      it "calls truncate on the faster transaction" do
+        faster_transaction.should_receive(:truncate!)
+        subject
+      end
+
+      it "calls convert_values_to_primitives on the (slower) transaction" do
+        transaction.should_receive(:convert_values_to_primitives!)
+        subject
+      end
+
+      it "indexes the slow transaction" do
+        expect { subject }.to change(aggregator, :slowness_index).
+          to({faster_transaction.action => transaction})
+      end
+    end
+  end
+
+end

data/spec/appsignal/inactive_railtie_spec.rb

@@ -21,7 +21,8 @@ describe "Inactive Appsignal::Railtie" do
         end
         MyTempApp::Application.initialize!
 
-        MyTempApp::Application.middleware.to_a.should_not include Appsignal::Middleware
+        MyTempApp::Application.middleware.to_a.
+          should_not include Appsignal::Listener
       end
       Process.wait(pid)
       raise 'Example failed' unless $?.exitstatus == 0

data/spec/appsignal/{middleware_spec.rb → listener_spec.rb}

@@ -10,11 +10,11 @@ class AppWithError
   end
 end
 
-describe Appsignal::Middleware do
+describe Appsignal::Listener do
   describe '#call' do
     let(:app) { stub(:call => true) }
     let(:env) { {'action_dispatch.request_id' => '1'} }
-    let(:middleware) { Appsignal::Middleware.new(app, {})}
+    let(:middleware) { Appsignal::Listener.new(app, {})}
     let(:current) { stub(:complete! => true, :add_exception => true) }
     before { Appsignal::Transaction.stub(:current => current) }
 

data/spec/appsignal/middleware/action_view_sanitizer_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Appsignal::Middleware::ActionViewSanitizer do
+  let(:klass) { Appsignal::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

data/spec/appsignal/middleware/active_record_sanitizer_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe Appsignal::Middleware::ActiveRecordSanitizer do
+  let(:klass) { Appsignal::Middleware::ActiveRecordSanitizer }
+  let(:sql_event_sanitizer) { klass.new }
+  let(:connection_config) { {} }
+  before do
+    ActiveRecord::Base.stub(
+      :connection_config => connection_config
+    )
+  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

data/spec/appsignal/middleware/chain_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Appsignal::Middleware do
+  let(:chain_klass) { Appsignal::Middleware::Chain }
+  let(:entry_klass) { Appsignal::Middleware::Entry }
+  let(:chain) { chain_klass.new }
+  let(:entry) { entry_klass.new(object, {:foo => :bar}) }
+
+  describe Appsignal::Middleware::Chain do
+    let(:object) { mock(:object) }
+    let(:other_object) { mock(:other_object) }
+
+    describe "#initialize" do
+      it "yields itself when passing a block" do
+        chain_klass.new { |o| o.should be_instance_of chain_klass }
+      end
+    end
+
+    describe "#remove" do
+      subject { chain.remove(object) }
+      before { chain.add(other_object) }
+
+      context "when it doesn't find the object" do
+        specify { expect { subject }.to_not raise_error }
+      end
+
+      context "when it finds the object" do
+        before { chain.add(object) }
+
+        specify { expect { subject }.to change(chain.entries, :count).by(-1) }
+      end
+    end
+
+    describe "#add" do
+      subject { chain.add(object) }
+
+      context "adding a new object" do
+        specify { expect { subject }.to change(chain.entries, :count).by(1) }
+      end
+
+      context "trying to add a duplicate (even with different arguments)" do
+        before { chain.add(object, :some_arguments) }
+
+        specify { expect { subject }.to_not change(chain.entries, :count).by(1) }
+      end
+    end
+
+    context "with a chain holding three items" do
+      subject { chain.entries.map(&:klass) }
+      before { [:first, :second, :third].each { |o| chain.add(o) } }
+
+      describe "#insert_before" do
+
+        context "before the second" do
+          before { chain.insert_before(:second, :object) }
+
+          it { should == [:first, :object, :second, :third] }
+        end
+
+        context "before the first" do
+          before { chain.insert_before(:first, :object) }
+
+          it { should == [:object, :first, :second, :third] }
+        end
+      end
+
+      describe "#insert_after" do
+
+        context "after the second" do
+          before { chain.insert_after(:second, :object) }
+
+          it { should == [:first, :second, :object, :third] }
+        end
+
+        context "after the third" do
+          before { chain.insert_after(:third, :object) }
+
+          it { should == [:first, :second, :third, :object] }
+        end
+      end
+
+      describe "#exists?" do
+        subject { chain.exists?(object) }
+
+        context "when it is in the chain" do
+          let(:object) { :first }
+
+          it { should be_true }
+        end
+
+        context "when it is not" do
+          let(:object) { :unknown }
+
+          it { should be_false }
+        end
+      end
+
+      describe "#retrieve" do
+        specify { chain.entries.each { |o| o.should_receive(:make_new) } }
+
+        after { chain.retrieve }
+      end
+
+      describe "#clear" do
+        before { chain.clear }
+        subject { chain.entries }
+
+        it { should be_empty }
+      end
+    end
+
+    describe "#invoke" do
+      let(:recorder) { [] }
+      subject { chain.invoke(:unsused) }
+      before(:all) do
+        TestInvoker1 = Struct.new(:id, :recorder) do
+          def call(event)
+            recorder << "Before#{id}"
+            yield
+            recorder << "After#{id}"
+          end
+        end
+        TestInvoker3 = Class.new(TestInvoker1)
+      end
+
+      context "all yielding entries" do
+        before do
+          TestInvoker2 = Class.new(TestInvoker1)
+
+          chain.add(TestInvoker1, 1, recorder)
+          chain.add(TestInvoker2, 2, recorder)
+          chain.add(TestInvoker3, 3, recorder)
+        end
+
+        it { should == %w(Before1 Before2 Before3 After3 After2 After1) }
+      end
+
+      context "a non yielding entry" do
+        before do
+          TestBlocker = Struct.new(:recorder) do
+            def call(event)
+              recorder << 'End-of-the-line!'
+            end
+          end
+
+          chain.add(TestInvoker1, 1, recorder)
+          chain.add(TestBlocker, recorder)
+          chain.add(TestInvoker3, 3, recorder)
+        end
+
+        it { should == %w(Before1 End-of-the-line! After1) }
+      end
+    end
+  end
+
+  describe Appsignal::Middleware::Entry do
+
+    describe "#make_new" do
+      let(:object) { mock }
+      subject { entry.make_new }
+
+      it "initializes the passed object" do
+        object.should_receive(:new)
+        subject
+      end
+    end
+  end
+end