appsignal 0.12.beta.31 → 0.12.beta.32

data/spec/lib/appsignal/integrations/padrino_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+begin
+  require 'padrino'
+rescue LoadError
+end
+
+if padrino_present?
+  describe "Padrino integration"   do
+    require File.expand_path('lib/appsignal/integrations/padrino.rb')
+
+    class ClassWithRouter
+      include Padrino::Routing
+    end
+
+    before do
+      Appsignal.stub(
+        :active?      => true,
+        :start        => true,
+        :start_logger => true
+      )
+    end
+
+    describe "Appsignal::Integrations::PadrinoPlugin" do
+      it "should start the logger on init" do
+        expect( Appsignal ).to receive(:start_logger)
+      end
+
+      it "should start appsignal on init" do
+        expect( Appsignal ).to receive(:start)
+      end
+
+      context "when not active" do
+        before { Appsignal.stub(:active? => false) }
+
+        it "should not add the Listener middleware to the stack" do
+          expect( Padrino ).to_not receive(:use)
+        end
+      end
+
+      after { Appsignal::Integrations::PadrinoPlugin.init }
+    end
+
+    describe "Padrino::Routing::InstanceMethods" do
+      let(:base)     { double }
+      let(:router)   { ClassWithRouter.new }
+      let(:env)      { {} }
+      let(:settings) { double(:name => 'TestApp') }
+
+      describe "#route!" do
+        let(:request) do
+          double(
+            :params          => {'id' => 1},
+            :session         => {'user_id' => 123},
+            :request_method  => 'GET',
+            :path            => '/users/1',
+            :controller      => 'users',
+            :action          => 'show',
+            :env             => {}
+          )
+        end
+
+        before do
+          router.stub(
+            :route_without_appsignal => true,
+            :request                 => request,
+            :env                     => env,
+            :settings                => settings,
+            :get_payload_action      => 'controller#action'
+          )
+        end
+
+        context "when Sinatra tells us it's a static file" do
+          let(:env) { {'sinatra.static_file' => true} }
+
+          it "should call the original method" do
+            expect( router ).to receive(:route_without_appsignal)
+          end
+
+          it "should not instrument the request" do
+            expect( ActiveSupport::Notifications ).to_not receive(:instrument)
+          end
+
+          after { router.route!(base) }
+        end
+
+        context "when appsignal is not active" do
+          before { Appsignal.stub(:active? => false) }
+
+          it "should call the original method" do
+            expect( router ).to receive(:route_without_appsignal)
+          end
+
+          it "should not instrument the request" do
+            expect( ActiveSupport::Notifications ).to_not receive(:instrument)
+          end
+
+          after { router.route!(base) }
+        end
+
+        context "with a dynamic request" do
+          let(:transaction) do
+              double(
+                :set_http_or_background_action => nil,
+                :set_http_or_background_queue_start => nil,
+                :set_metadata => nil,
+                :set_action => nil,
+                :set_error => nil
+              )
+          end
+          before { Appsignal::Transaction.stub(:create => transaction) }
+
+          context "without an error" do
+            it "should create a transaction" do
+              expect( Appsignal::Transaction ).to receive(:create).with(
+                kind_of(String),
+                Appsignal::Transaction::HTTP_REQUEST,
+                request
+              ).and_return(transaction)
+            end
+
+            it "should call the original routing method" do
+              expect( router ).to receive(:route_without_appsignal)
+            end
+
+            it "should instrument the action" do
+              expect( ActiveSupport::Notifications ).to receive(:instrument).with('process_action.padrino')
+            end
+
+            it "should set metadata" do
+              expect( transaction ).to receive(:set_metadata).twice
+            end
+
+            it "should set the action on the transaction" do
+              expect( transaction ).to receive(:set_action).with('controller#action')
+            end
+
+            after { router.route!(base) }
+          end
+
+          context "with an error" do
+            let(:error) { VerySpecificError.new }
+            before { router.stub(:route_without_appsignal).and_raise(error) }
+
+            it "should add the exception to the current transaction" do
+              expect( transaction ).to receive(:set_error).with(error)
+
+              router.route!(base) rescue VerySpecificError
+            end
+          end
+        end
+      end
+
+      describe "#get_payload_action" do
+        before { router.stub(:settings  => settings) }
+
+        context "when request is nil" do
+          it "should return the site" do
+            expect( router.get_payload_action(nil) ).to eql('TestApp')
+          end
+        end
+
+        context "when there's no route object" do
+          let(:request) { double(:controller => 'Controller', :action => 'action') }
+
+          it "should return the site name, controller and action" do
+            expect( router.get_payload_action(request) ).to eql('TestApp:Controller#action')
+          end
+
+          context "when there's no action" do
+            let(:request) { double(:controller => 'Controller', :fullpath => '/action') }
+
+            it "should return the site name, controller and fullpath" do
+              expect( router.get_payload_action(request) ).to eql('TestApp:Controller#/action')
+            end
+          end
+        end
+
+        context "when request has a route object" do
+          let(:request)      { double }
+          let(:route_object) { double(:original_path => '/accounts/edit/:id') }
+          before             { request.stub(:route_obj => route_object) }
+
+          it "should return the original path" do
+            expect( router.get_payload_action(request) ).to eql('TestApp:/accounts/edit/:id')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/appsignal/integrations/rails_spec.rb

@@ -46,7 +46,6 @@ if rails_present?
             ENV.delete('APPSIGNAL_APP_ENV')
           end
 
-
           its(:env) { should == 'env_test' }
         end
       end
@@ -55,7 +54,7 @@ if rails_present?
         it "should have added the listener middleware" do
           expect( app.middleware ).to receive(:insert_before).with(
             ActionDispatch::RemoteIp,
-            Appsignal::Rack::Listener
+            Appsignal::Rack::RailsInstrumentation
           )
         end
 
@@ -76,11 +75,11 @@ if rails_present?
           it "should have added the listener and JSExceptionCatcher middleware" do
             expect( app.middleware ).to receive(:insert_before).with(
               ActionDispatch::RemoteIp,
-              Appsignal::Rack::Listener
+              Appsignal::Rack::RailsInstrumentation
             )
 
             expect( app.middleware ).to receive(:insert_before).with(
-              Appsignal::Rack::Listener,
+              Appsignal::Rack::RailsInstrumentation,
               Appsignal::Rack::JSExceptionCatcher
             )
           end

data/spec/lib/appsignal/integrations/rake_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'rake'
+describe "Rack integration" do
+  let(:file) { File.expand_path('lib/appsignal/integrations/rake.rb') }
+  let(:app)  { double(:current_scope => nil) }
+  let(:task) { Rake::Task.new('task', app) }
+  before do
+    load file
+    task.stub(
+      :name                     => 'task:name',
+      :invoke_without_appsignal => true
+    )
+  end
+
+  describe "#invoke" do
+    before { Appsignal.stub(:active? => true) }
+
+    it "should call with appsignal monitoring" do
+      expect( task ).to receive(:invoke_with_appsignal).with(['foo'])
+    end
+
+    context "when not active" do
+      before { Appsignal.stub(:active? => false) }
+
+      it "should NOT call with appsignal monitoring" do
+        expect( task ).to_not receive(:invoke_with_appsignal).with(['foo'])
+      end
+
+      it "should call the original task" do
+        expect( task ).to receive(:invoke_without_appsignal).with(['foo'])
+      end
+    end
+
+    after { task.invoke(['foo']) }
+  end
+
+  describe "#invoke_with_appsignal" do
+    context "with transaction" do
+      let!(:transaction) { regular_transaction }
+      let!(:agent)       { double('Agent', :send_queue => true) }
+      before do
+        SecureRandom.stub(:uuid => '123')
+        Appsignal::Transaction.stub(:create => transaction)
+        Appsignal.stub(:agent => agent, :active? => true)
+      end
+
+      it "should call the original task" do
+        expect( task ).to receive(:invoke_without_appsignal).with('foo')
+      end
+
+      context "with an exception" do
+        let(:exception) { VerySpecificError.new }
+
+        before do
+          task.stub(:invoke_without_appsignal).and_raise(exception)
+        end
+
+        it "should create a transaction" do
+          expect( Appsignal::Transaction ).to receive(:create).with(
+            '123',
+            Appsignal::Transaction::BACKGROUND_JOB,
+            kind_of(Appsignal::Transaction::GenericRequest)
+          )
+        end
+
+        it "should set the action on the transaction" do
+          expect( transaction ).to receive(:set_action).with('task:name')
+        end
+
+        it "should add the exception to the transaction" do
+          expect( transaction ).to receive(:set_error).with(exception)
+        end
+      end
+    end
+
+    after { task.invoke_with_appsignal('foo') rescue VerySpecificError }
+  end
+end

data/spec/lib/appsignal/integrations/resque_spec.rb

@@ -25,7 +25,7 @@ describe "Resque integration" do
     end
 
     describe :around_perform_resque_plugin do
-      let(:transaction) { Appsignal::Transaction.new('1', {}) }
+      let(:transaction) { background_job_transaction }
       let(:job) { Resque::Job }
       let(:invoked_job) { nil }
       before do
@@ -55,7 +55,7 @@ describe "Resque integration" do
 
       context "with exception" do
         it "should set the exception" do
-          transaction.should_receive(:set_error)
+          Appsignal::Transaction.any_instance.should_receive(:set_error)
         end
 
         after do

data/spec/lib/appsignal/integrations/sequel_spec.rb

@@ -10,15 +10,14 @@ describe "Sequel integration", if: sequel_present? do
   end
 
   context "with Sequel" do
-    before { Appsignal::Transaction.create('uuid', 'test') }
+    before { Appsignal::Transaction.create('uuid', Appsignal::Transaction::HTTP_REQUEST, 'test') }
 
     it "should instrument queries" do
       expect( Appsignal::Extension ).to receive(:start_event)
         .at_least(:once)
-        .with('uuid')
       expect( Appsignal::Extension ).to receive(:finish_event)
         .at_least(:once)
-        .with('uuid', "sql.sequel", "", "")
+        .with(kind_of(Integer), "sql.sequel", "", "")
 
       db['SELECT 1'].all
     end

data/spec/lib/appsignal/integrations/sidekiq_spec.rb

@@ -15,7 +15,7 @@ describe "Sidekiq integration" do
 
   let(:worker) { double }
   let(:queue) { double }
-  let(:current_transaction) { Appsignal::Transaction.create(SecureRandom.uuid, {}) }
+  let(:current_transaction) { background_job_transaction }
   let(:item) {{
     'class'       => 'TestClass',
     'retry_count' => 0,
@@ -47,6 +47,23 @@ describe "Sidekiq integration" do
       )
     end
 
+    it "reports the correct job class for a ActiveJob wrapped job" do
+      item['wrapped'] = 'ActiveJobClass'
+      Appsignal.should_receive(:monitor_transaction).with(
+        'perform_job.sidekiq',
+        :class    => 'ActiveJobClass',
+        :method   => 'perform',
+        :metadata => {
+          'retry_count' => "0",
+          'queue'       => 'default',
+          'extra'       => 'data',
+          'wrapped'     => 'ActiveJobClass'
+        },
+        :params      => ['Model', "1"],
+        :queue_start => Time.parse('01-01-2001 10:00:00UTC')
+      )
+    end
+
     after do
       Timecop.freeze(Time.parse('01-01-2001 10:01:00UTC')) do
         Appsignal::Integrations::SidekiqPlugin.new.call(worker, item, queue) do
@@ -59,7 +76,7 @@ describe "Sidekiq integration" do
   context "with an erroring call" do
     let(:error) { VerySpecificError.new('the roof') }
     it "should add the exception to appsignal" do
-      current_transaction.should_receive(:set_error).with(error)
+      Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
     end
 
     after do
@@ -104,11 +121,11 @@ describe "Sidekiq integration" do
 
   describe "#truncate" do
     let(:very_long_text) do
-      "a" * 200
+      "a" * 400
     end
 
-    it "should truncate the text to 100 chars max" do
-      plugin.truncate(very_long_text).should == "#{'a' * 97}..."
+    it "should truncate the text to 200 chars max" do
+      plugin.truncate(very_long_text).should == "#{'a' * 197}..."
     end
   end
 

data/spec/lib/appsignal/integrations/sinatra_spec.rb

@@ -22,12 +22,6 @@ if defined?(::Sinatra)
       it { should be_a(Appsignal::Config) }
     end
 
-    it "should have added the listener middleware" do
-      Sinatra::Application.middleware.to_a.should include(
-        [Appsignal::Rack::Listener, [], nil]
-      )
-    end
-
     it "should have added the instrumentation middleware" do
       Sinatra::Application.middleware.to_a.should include(
         [Appsignal::Rack::SinatraInstrumentation, [], nil]

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -20,9 +20,9 @@ describe Appsignal::JSExceptionTransaction do
 
   describe "#initialize" do
     it "should call all required methods" do
-      expect( Appsignal::Extension ).to receive(:start_transaction).with('123abc').and_return(1)
+      expect( Appsignal::Extension ).to receive(:start_transaction).with('123abc', 'frontend').and_return(1)
 
-      expect( transaction ).to receive(:set_base_data)
+      expect( transaction ).to receive(:set_action)
       expect( transaction ).to receive(:set_metadata)
       expect( transaction ).to receive(:set_error)
       expect( transaction ).to receive(:set_error_data)
@@ -35,14 +35,12 @@ describe Appsignal::JSExceptionTransaction do
 
   describe "#set_base_data" do
     it "should call `Appsignal::Extension.set_transaction_basedata`" do
-      expect( Appsignal::Extension ).to receive(:set_transaction_base_data).with(
+      expect( Appsignal::Extension ).to receive(:set_transaction_action).with(
         kind_of(Integer),
-        'frontend',
         'ExceptionIncidentComponent',
-        0
       )
 
-      transaction.set_base_data
+      transaction.set_action
     end
   end
 

data/spec/lib/appsignal/params_sanitizer_spec.rb

@@ -6,39 +6,54 @@ class ErrorOnInspect
   end
 end
 
+class ClassWithInspect
+  def inspect
+    "#<ClassWithInspect foo=\"bar\"/>"
+  end
+end
+
 describe Appsignal::ParamsSanitizer do
   let(:klass) { Appsignal::ParamsSanitizer }
   let(:file) { uploaded_file }
   let(:params) do
     {
-      :text => 'string',
-      :file => file,
-      :hash => {
-        :nested_text => 'string',
+      :text       => 'string',
+      :file       => file,
+      :float      => 0.0,
+      :bool_true  => true,
+      :bool_false => false,
+      :int        => 1,
+      :hash       => {
+        :nested_text  => 'string',
         :nested_array => [
           'something',
           'else',
           file,
           {
-            :key => 'value',
+            :key  => 'value',
             :file => file,
           },
-          ErrorOnInspect.new
+          ErrorOnInspect.new,
+          ClassWithInspect.new
         ]
       }
     }
   end
   let(:sanitized_params) { klass.sanitize(params) }
-  let(:scrubbed_params) { klass.scrub(params) }
+  let(:scrubbed_params)  { klass.scrub(params) }
 
   describe ".sanitize!" do
     subject { params }
     before { klass.sanitize!(subject) }
 
     it { should be_instance_of Hash }
-    its([:text]) { should == 'string' }
-    its([:file]) { should be_instance_of String }
-    its([:file]) { should include '::UploadedFile' }
+    its([:text])        { should == 'string' }
+    its([:file])        { should be_instance_of String }
+    its([:file])        { should include '::UploadedFile' }
+    its([:float])       { should == 0.0 }
+    its([:int])         { should == 1 }
+    its([:bool_true])   { should == 'true' }
+    its([:bool_false])  { should == 'false' }
 
     context "hash" do
       subject { params[:hash] }
@@ -54,7 +69,8 @@ describe Appsignal::ParamsSanitizer do
         its([1]) { should == 'else' }
         its([2]) { should be_instance_of String }
         its([2]) { should include '::UploadedFile' }
-        its([4]) { should == '#<ErrorOnInspect/>' }
+        its([4]) { should == '#<ErrorOnInspect>' }
+        its([5]) { should == '#<ClassWithInspect>' }
 
         context "nested hash" do
           subject { params[:hash][:nested_array][3] }