appsignal 3.9.3 → 3.10.0

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

@@ -3,40 +3,133 @@ if DependencyHelper.padrino_present?
     require "appsignal/integrations/padrino"
 
     describe Appsignal::Integrations::PadrinoPlugin do
-      it "starts AppSignal on init" do
-        expect(Appsignal).to receive(:start)
+      let(:callbacks) { { :before_load => nil } }
+      before do
+        Appsignal.config = nil
+        allow(Padrino).to receive(:before_load)
+          .and_wrap_original do |original_method, *args, &block|
+            callbacks[:before_load] = block
+            original_method.call(*args, &block)
+          end
+      end
+      after { uninstall_padrino_integration }
+
+      def uninstall_padrino_integration
+        expected_middleware = [
+          Rack::Events,
+          Appsignal::Rack::SinatraBaseInstrumentation
+        ]
+        Padrino.middleware.delete_if do |middleware|
+          expected_middleware.include?(middleware.first)
+        end
       end
 
-      context "when not active" do
-        before { allow(Appsignal).to receive(:active?).and_return(false) }
+      context "when already active" do
+        before { allow(Appsignal).to receive(:active?).and_return(true) }
 
-        it "does not add the listener middleware to the stack" do
-          expect(Padrino).to_not receive(:use)
+        it "does not start AppSignal again" do
+          expect(Appsignal::Config).to_not receive(:new)
+          expect(Appsignal).to_not receive(:start)
+
+          Appsignal::Integrations::PadrinoPlugin.init
+          callbacks[:before_load].call
+        end
+
+        it "adds the instrumentation middleware to Sinatra::Base" do
+          Appsignal::Integrations::PadrinoPlugin.init
+          callbacks[:before_load].call
+
+          middlewares = Padrino.middleware
+          expect(middlewares).to include(
+            [Rack::Events, [[instance_of(Appsignal::Rack::EventHandler)]], nil]
+          )
+          expect(middlewares).to include(
+            [
+              Appsignal::Rack::SinatraBaseInstrumentation,
+              [
+                :instrument_event_name => "process_action.padrino"
+              ],
+              nil
+            ]
+          )
         end
       end
 
-      context "when APPSIGNAL_APP_ENV ENV var is provided" do
-        it "uses this as the environment" do
-          ENV["APPSIGNAL_APP_ENV"] = "custom"
+      context "with active config" do
+        before do
+          ENV["APPSIGNAL_APP_NAME"] = "My Padrino app name"
+          ENV["APPSIGNAL_APP_ENV"] = "test"
+          ENV["APPSIGNAL_PUSH_API_KEY"] = "my-key"
+        end
+
+        it "starts AppSignal on init" do
+          expect(Appsignal).to_not be_active
 
-          # Reset the plugin to pull down the latest data
           Appsignal::Integrations::PadrinoPlugin.init
+          callbacks[:before_load].call
+
+          expect(Appsignal).to be_active
+          middlewares = Padrino.middleware
+          expect(middlewares).to include(
+            [Rack::Events, [[instance_of(Appsignal::Rack::EventHandler)]], nil]
+          )
+          expect(middlewares).to include(
+            [
+              Appsignal::Rack::SinatraBaseInstrumentation,
+              [
+                :instrument_event_name => "process_action.padrino"
+              ],
+              nil
+            ]
+          )
+        end
+
+        context "when APPSIGNAL_APP_ENV ENV var is provided" do
+          it "uses this as the environment" do
+            ENV["APPSIGNAL_APP_ENV"] = "custom"
+
+            Appsignal::Integrations::PadrinoPlugin.init
+            callbacks[:before_load].call
 
-          expect(Appsignal.config.env).to eq("custom")
+            expect(Appsignal.config.env).to eq("custom")
+          end
+        end
+
+        context "when APPSIGNAL_APP_ENV ENV var is not provided" do
+          it "uses the Padrino environment" do
+            Appsignal::Integrations::PadrinoPlugin.init
+            callbacks[:before_load].call
+
+            expect(Padrino.env.to_s).to eq("test")
+            expect(Appsignal.config.env).to eq(Padrino.env.to_s)
+          end
         end
       end
 
-      context "when APPSIGNAL_APP_ENV ENV var is not provided" do
-        it "uses the Padrino environment" do
-          # Reset the plugin to pull down the latest data
+      context "when not active" do
+        it "does not add the listener middleware to the stack" do
+          expect(Appsignal).to_not be_active
+
           Appsignal::Integrations::PadrinoPlugin.init
+          callbacks[:before_load].call
 
-          expect(Padrino.env.to_s).to eq("test")
-          expect(Appsignal.config.env).to eq(Padrino.env.to_s)
+          expect(Appsignal).to_not be_active
+          middlewares = Padrino.middleware
+          expect(middlewares).to_not include(
+            [Rack::Events, [[instance_of(Appsignal::Rack::EventHandler)]], nil]
+          )
+          expect(middlewares).to_not include(
+            [
+              Appsignal::Rack::SinatraBaseInstrumentation,
+              [
+                :request_class => ::Sinatra::Request,
+                :instrument_event_name => "process_action.padrino"
+              ],
+              nil
+            ]
+          )
         end
       end
-
-      after { Appsignal::Integrations::PadrinoPlugin.init }
     end
 
     describe Padrino::Routing::InstanceMethods do
@@ -50,9 +143,9 @@ if DependencyHelper.padrino_present?
       # TODO: use an instance double
       let(:settings) { double(:name => "TestApp") }
       around { |example| keep_transactions { example.run } }
+      before { Appsignal.config = nil }
 
       describe "routes" do
-        let(:request_kind) { kind_of(Sinatra::Request) }
         let(:env) do
           {
             "REQUEST_METHOD" => "GET",
@@ -83,20 +176,7 @@ if DependencyHelper.padrino_present?
           end
         end
 
-        def expect_a_transaction_to_be_created
-          transaction = last_transaction
-          expect(transaction).to have_id
-          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-          expect(transaction).to include_metadata(
-            "path" => path,
-            "method" => "GET"
-          )
-          expect(transaction).to include_event("name" => "process_action.padrino")
-          expect(transaction).to be_completed
-        end
-
         context "when AppSignal is not active" do
-          before { allow(Appsignal).to receive(:active?).and_return(false) }
           let(:path) { "/foo" }
           before { app.controllers { get(:foo) { "content" } } }
 
@@ -108,16 +188,17 @@ if DependencyHelper.padrino_present?
         end
 
         context "when AppSignal is active" do
-          before { start_agent }
+          let(:transaction) { http_request_transaction }
+          before do
+            start_agent
+            set_current_transaction(transaction)
+          end
 
           context "with not existing route" do
             let(:path) { "/404" }
 
             it "instruments the request" do
               expect(response).to match_response(404, /^GET /404/)
-
-              expect_a_transaction_to_be_created
-              # Uses path for action name
               expect(last_transaction).to have_action("PadrinoTestApp#unknown")
             end
           end
@@ -130,9 +211,8 @@ if DependencyHelper.padrino_present?
             end
 
             it "does not instrument the request" do
-              expect do
-                expect(response).to match_response(200, "Static!")
-              end.to_not(change { created_transactions.count })
+              expect(response).to match_response(200, "Static!")
+              expect(last_transaction).to_not have_action
             end
           end
 
@@ -145,11 +225,7 @@ if DependencyHelper.padrino_present?
             end
 
             it "falls back on Sinatra::Request#route_obj.original_path" do
-              expect do
-                expect(response).to match_response(200, "content")
-              end.to(change { created_transactions.count }.by(1))
-
-              expect_a_transaction_to_be_created
+              expect(response).to match_response(200, "content")
               expect(last_transaction).to have_action("PadrinoTestApp:/my_original_path/:id")
             end
           end
@@ -164,118 +240,92 @@ if DependencyHelper.padrino_present?
 
             it "falls back on app name" do
               expect(response).to match_response(200, "content")
-              expect_a_transaction_to_be_created
               expect(last_transaction).to have_action("PadrinoTestApp#unknown")
             end
           end
 
           context "with existing route" do
-            context "with an exception in the controller" do
-              let(:path) { "/exception" }
-              before do
-                app.controllers { get(:exception) { raise ExampleException, "error message" } }
-                expect { response }.to raise_error(ExampleException, "error message")
-                expect_a_transaction_to_be_created
-              end
+            let(:path) { "/" }
+            def make_request
+              expect(response).to match_response(200, "content")
+            end
 
-              it "sets the action name based on the app name and action name" do
-                expect(last_transaction).to have_action("PadrinoTestApp:#exception")
-              end
+            context "with action name as symbol" do
+              context "with :index helper" do
+                before do
+                  # :index == "/"
+                  app.controllers { get(:index) { "content" } }
+                end
 
-              it "sets the error on the transaction" do
-                expect(last_transaction).to have_error("ExampleException", "error message")
+                it "sets the action with the app name and action name" do
+                  make_request
+                  expect(last_transaction).to have_action("PadrinoTestApp:#index")
+                end
               end
-            end
 
-            context "without an exception in the controller" do
-              let(:path) { "/" }
-              def make_request
-                expect(response).to match_response(200, "content")
+              context "with custom action name" do
+                let(:path) { "/foo" }
+                before do
+                  app.controllers { get(:foo) { "content" } }
+                end
+
+                it "sets the action with the app name and action name" do
+                  make_request
+                  expect(last_transaction).to have_action("PadrinoTestApp:#foo")
+                end
               end
+            end
 
-              context "with action name as symbol" do
-                context "with :index helper" do
-                  before do
-                    # :index == "/"
-                    app.controllers { get(:index) { "content" } }
-                  end
-
-                  it "sets the action with the app name and action name" do
-                    make_request
-                    expect_a_transaction_to_be_created
-                    expect(last_transaction).to have_action("PadrinoTestApp:#index")
-                  end
+            context "with an action defined with a path" do
+              context "with root path" do
+                before do
+                  # :index == "/"
+                  app.controllers { get("/") { "content" } }
                 end
 
-                context "with custom action name" do
-                  let(:path) { "/foo" }
-                  before do
-                    app.controllers { get(:foo) { "content" } }
-                  end
-
-                  it "sets the action with the app name and action name" do
-                    make_request
-                    expect_a_transaction_to_be_created
-                    expect(last_transaction).to have_action("PadrinoTestApp:#foo")
-                  end
+                it "sets the action with the app name and action path" do
+                  make_request
+                  expect(last_transaction).to have_action("PadrinoTestApp:#/")
                 end
               end
 
-              context "with an action defined with a path" do
-                context "with root path" do
-                  before do
-                    # :index == "/"
-                    app.controllers { get("/") { "content" } }
-                  end
-
-                  it "sets the action with the app name and action path" do
-                    make_request
-                    expect_a_transaction_to_be_created
-                    expect(last_transaction).to have_action("PadrinoTestApp:#/")
-                  end
+              context "with custom path" do
+                let(:path) { "/foo" }
+                before do
+                  app.controllers { get("/foo") { "content" } }
                 end
 
-                context "with custom path" do
-                  let(:path) { "/foo" }
-                  before do
-                    app.controllers { get("/foo") { "content" } }
-                  end
-
-                  it "sets the action with the app name and action path" do
-                    make_request
-                    expect_a_transaction_to_be_created
-                    expect(last_transaction).to have_action("PadrinoTestApp:#/foo")
-                  end
+                it "sets the action with the app name and action path" do
+                  make_request
+                  expect(last_transaction).to have_action("PadrinoTestApp:#/foo")
                 end
               end
+            end
+
+            context "with controller" do
+              let(:path) { "/my_controller" }
 
-              context "with controller" do
-                let(:path) { "/my_controller" }
+              context "with controller as name" do
+                before do
+                  # :index == "/"
+                  app.controllers(:my_controller) { get(:index) { "content" } }
+                end
 
-                context "with controller as name" do
-                  before do
-                    # :index == "/"
-                    app.controllers(:my_controller) { get(:index) { "content" } }
-                  end
+                it "sets the action with the app name, controller name and action name" do
+                  make_request
+                  expect(last_transaction).to have_action("PadrinoTestApp:my_controller#index")
+                end
+              end
 
-                  it "sets the action with the app name, controller name and action name" do
-                    make_request
-                    expect_a_transaction_to_be_created
-                    expect(last_transaction).to have_action("PadrinoTestApp:my_controller#index")
-                  end
+              context "with controller as path" do
+                before do
+                  # :index == "/"
+                  app.controllers("/my_controller") { get(:index) { "content" } }
                 end
 
-                context "with controller as path" do
-                  before do
-                    # :index == "/"
-                    app.controllers("/my_controller") { get(:index) { "content" } }
-                  end
-
-                  it "sets the action with the app name, controller name and action path" do
-                    make_request
-                    expect_a_transaction_to_be_created
-                    expect(last_transaction).to have_action("PadrinoTestApp:/my_controller#index")
-                  end
+                it "sets the action with the app name, controller name and action path" do
+                  make_request
+                  expect(last_transaction).to have_action("PadrinoTestApp:/my_controller#index")
                 end
               end
             end

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

@@ -7,8 +7,12 @@ if DependencyHelper.sinatra_present?
 
   # "Uninstall" the AppSignal integration
   def uninstall_sinatra_integration
+    expected_middleware = [
+      Rack::Events,
+      Appsignal::Rack::SinatraBaseInstrumentation
+    ]
     Sinatra::Base.instance_variable_get(:@middleware).delete_if do |middleware|
-      middleware.first == Appsignal::Rack::SinatraBaseInstrumentation
+      expected_middleware.include?(middleware.first)
     end
   end
 
@@ -29,7 +33,11 @@ if DependencyHelper.sinatra_present?
 
       it "adds the instrumentation middleware to Sinatra::Base" do
         install_sinatra_integration
-        expect(Sinatra::Base.middleware.to_a).to include(
+        middlewares = Sinatra::Base.middleware.to_a
+        expect(middlewares).to include(
+          [Rack::Events, [[instance_of(Appsignal::Rack::EventHandler)]], nil]
+        )
+        expect(middlewares).to include(
           [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
         )
       end

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

@@ -15,31 +15,60 @@ if DependencyHelper.webmachine_present?
 
   describe Appsignal::Integrations::WebmachineIntegration do
     let(:request) do
-      Webmachine::Request.new("GET", "http://google.com:80/foo", {}, nil)
+      Webmachine::Request.new(
+        "GET",
+        "http://google.com:80/foo?param1=value1&param2=value2",
+        {},
+        nil
+      )
     end
-    let(:resource) { double(:trace? => false, :handle_exception => true, :"code=" => nil) }
-    let(:response) { Response.new }
-    let(:fsm) { Webmachine::Decision::FSM.new(resource, request, response) }
-    before(:context) { start_agent }
-    around { |example| keep_transactions { example.run } }
+    let(:app) do
+      proc do
+        def to_html
+          "Some HTML"
+        end
+      end
+    end
+    let(:resource) do
+      app_block = app
+      Class.new(Webmachine::Resource) do
+        class_eval(&app_block) if app_block
 
-    # Make sure the request responds to the method we need to get query params.
-    describe "request" do
-      it "responds to #query" do
-        expect(request).to respond_to(:query)
+        def self.name
+          "MyResource"
+        end
       end
     end
+    let(:resource_instance) { resource.new(request, response) }
+    let(:response) { Webmachine::Response.new }
+    let(:fsm) { Webmachine::Decision::FSM.new(resource_instance, request, response) }
+    before { start_agent }
+    around { |example| keep_transactions { example.run } }
 
     describe "#run" do
-      before { allow(fsm).to receive(:call).and_call_original }
-
       it "creates a transaction" do
         expect { fsm.run }.to(change { created_transactions.count }.by(1))
       end
 
       it "sets the action" do
         fsm.run
-        expect(last_transaction).to have_action("RSpec::Mocks::Double#GET")
+        expect(last_transaction).to have_action("MyResource#GET")
+      end
+
+      context "with action already set" do
+        let(:app) do
+          proc do
+            def to_html
+              Appsignal.set_action("Custom Action")
+              "Some HTML"
+            end
+          end
+        end
+
+        it "doesn't overwrite the action" do
+          fsm.run
+          expect(last_transaction).to have_action("Custom Action")
+        end
       end
 
       it "records an instrumentation event" do
@@ -47,16 +76,35 @@ if DependencyHelper.webmachine_present?
         expect(last_transaction).to include_event("name" => "process_action.webmachine")
       end
 
+      it "sets the params" do
+        fsm.run
+        expect(last_transaction).to include_params("param1" => "value1", "param2" => "value2")
+      end
+
       it "closes the transaction" do
         fsm.run
         expect(last_transaction).to be_completed
         expect(current_transaction?).to be_falsy
       end
 
-      it "sets a response code" do
-        expect(fsm.response.code).to be_nil
-        fsm.run
-        expect(fsm.response.code).not_to be_nil
+      context "with parent transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "sets the action" do
+          fsm.run
+          expect(last_transaction).to have_action("MyResource#GET")
+        end
+
+        it "sets the params" do
+          fsm.run
+          last_transaction._sample
+          expect(last_transaction).to include_params("param1" => "value1", "param2" => "value2")
+        end
+
+        it "does not close the transaction" do
+          expect(last_transaction).to_not be_completed
+        end
       end
     end