appsignal 3.10.0 → 3.12.0

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

@@ -0,0 +1,277 @@
+if DependencyHelper.padrino_present?
+  describe "Appsignal::Loaders::PadrinoLoader" do
+    before { Appsignal.config = nil }
+
+    describe "#on_load" do
+      it "registers Padrino default config" do
+        load_loader(:padrino)
+
+        expect(Appsignal::Config.loader_defaults).to include([
+          :padrino,
+          {
+            :env => :test,
+            :root_path => Padrino.mounted_root
+          }
+        ])
+      end
+    end
+
+    describe "#on_start" do
+      let(:callbacks) { { :before_load => nil } }
+      before do
+        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
+
+      it "adds the instrumentation middleware to Padrino" do
+        load_loader(:padrino)
+        start_loader(:padrino)
+
+        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
+
+    describe "Padrino integration" do
+      class PadrinoClassWithRouter
+        include Padrino::Routing
+      end
+
+      let(:base)     { double }
+      let(:router)   { PadrinoClassWithRouter.new }
+      let(:env)      { {} }
+      # TODO: use an instance double
+      let(:settings) { double(:name => "TestApp") }
+      around { |example| keep_transactions { example.run } }
+      before { Appsignal.config = nil }
+
+      describe "routes" do
+        let(:env) do
+          {
+            "REQUEST_METHOD" => "GET",
+            "PATH_INFO" => path,
+            "REQUEST_PATH" => path,
+            "rack.input" => StringIO.new
+          }
+        end
+        let(:app) do
+          Class.new(Padrino::Application) do
+            def self.name
+              "PadrinoTestApp"
+            end
+          end
+        end
+        let(:response) { app.call(env) }
+
+        def fetch_body(body)
+          if body.respond_to?(:response)
+            _, _, nested_body = body.response.to_a
+            fetch_body(nested_body)
+          elsif body.respond_to?(:to_ary)
+            body.to_ary
+          else
+            body
+          end
+        end
+
+        RSpec::Matchers.define :match_response do |expected_status, expected_body|
+          match do |response|
+            status, _headers, potential_body = response
+            body = fetch_body(potential_body)
+
+            matches_body =
+              if expected_body.is_a?(Regexp)
+                body.join =~ expected_body
+              else
+                body == [expected_body].compact
+              end
+            status == expected_status && matches_body
+          end
+        end
+
+        context "when AppSignal is not active" do
+          let(:path) { "/foo" }
+          before { app.controllers { get(:foo) { "content" } } }
+
+          it "does not instrument the request" do
+            expect do
+              expect(response).to match_response(200, "content")
+            end.to_not(change { created_transactions.count })
+          end
+        end
+
+        context "when AppSignal is active" do
+          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(last_transaction).to have_action("PadrinoTestApp#unknown")
+            end
+          end
+
+          context "when Sinatra tells us it's a static file" do
+            let(:path) { "/static" }
+            before do
+              env["sinatra.static_file"] = true
+              app.controllers { get(:static) { "Static!" } }
+            end
+
+            it "does not instrument the request" do
+              expect(response).to match_response(200, "Static!")
+              expect(last_transaction).to_not have_action
+            end
+          end
+
+          # Older Padrino versions don't support `action` (v11.0+)
+          context "without #action on Sinatra::Request" do
+            let(:path) { "/my_original_path/10" }
+            before do
+              allow_any_instance_of(Sinatra::Request).to receive(:action).and_return(nil)
+              app.controllers { get(:my_original_path, :with => :id) { "content" } }
+            end
+
+            it "falls back on Sinatra::Request#route_obj.original_path" do
+              expect(response).to match_response(200, "content")
+              expect(last_transaction).to have_action("PadrinoTestApp:/my_original_path/:id")
+            end
+          end
+
+          context "without Sinatra::Request#route_obj.original_path" do
+            let(:path) { "/my_original_path" }
+            before do
+              allow_any_instance_of(Sinatra::Request).to receive(:action).and_return(nil)
+              allow_any_instance_of(Sinatra::Request).to receive(:route_obj).and_return(nil)
+              app.controllers { get(:my_original_path) { "content" } }
+            end
+
+            it "falls back on app name" do
+              expect(response).to match_response(200, "content")
+              expect(last_transaction).to have_action("PadrinoTestApp#unknown")
+            end
+          end
+
+          context "with existing route" do
+            let(:path) { "/" }
+            def make_request
+              expect(response).to match_response(200, "content")
+            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(last_transaction).to have_action("PadrinoTestApp:#index")
+                end
+              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(last_transaction).to have_action("PadrinoTestApp:#foo")
+                end
+              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(last_transaction).to have_action("PadrinoTestApp:#/")
+                end
+              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(last_transaction).to have_action("PadrinoTestApp:#/foo")
+                end
+              end
+            end
+
+            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
+
+                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
+
+              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(last_transaction).to have_action("PadrinoTestApp:/my_controller#index")
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+if DependencyHelper.sinatra_present?
+  describe "Appsignal::Loaders::SinatraLoader" do
+    before { Appsignal.config = nil }
+
+    describe "#on_load" do
+      it "registers Sinatra default config" do
+        ::Sinatra::Application.settings.root = "/some/path"
+        load_loader(:sinatra)
+
+        expect(Appsignal::Config.loader_defaults).to include([
+          :sinatra,
+          {
+            :env => :test,
+            :root_path => "/some/path"
+          }
+        ])
+      end
+    end
+
+    describe "#on_start" do
+      after { uninstall_sinatra_integration }
+
+      def uninstall_sinatra_integration
+        expected_middleware = [
+          Rack::Events,
+          Appsignal::Rack::SinatraBaseInstrumentation
+        ]
+        Sinatra::Base.instance_variable_get(:@middleware).delete_if do |middleware|
+          expected_middleware.include?(middleware.first)
+        end
+      end
+
+      it "adds the instrumentation middleware to Sinatra::Base" do
+        load_loader(:sinatra)
+        start_loader(:sinatra)
+
+        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
+    end
+  end
+end

data/spec/lib/appsignal/loaders_spec.rb

@@ -0,0 +1,137 @@
+describe Appsignal::Loaders do
+  describe ".register" do
+    before do
+      define_loader(:test_loader) do
+        def on_load
+          puts "do something on_load"
+          register_config_defaults(
+            :root_path => "/some/path",
+            :env => "test env",
+            :active => false
+          )
+        end
+      end
+    end
+
+    it "registers a loader" do
+      define_loader(:test_loader)
+      expect(Appsignal::Loaders.loaders).to have_key(:test_loader)
+    end
+  end
+
+  describe ".unregister" do
+    it "unregisters a loader" do
+      define_loader(:test_loader)
+      expect(Appsignal::Loaders.loaders).to have_key(:test_loader)
+
+      Appsignal::Loaders.unregister(:test_loader)
+      expect(Appsignal::Loaders.loaders).to_not have_key(:test_loader)
+    end
+  end
+
+  describe ".load" do
+    it "calls the Loader's on_loader method" do
+      Appsignal::Testing.store[:loader_loaded] = 0
+      define_loader(:test_loader) do
+        def on_load
+          Appsignal::Testing.store[:loader_loaded] += 1
+        end
+      end
+      Appsignal::Loaders.load(:test_loader)
+
+      expect(Appsignal::Testing.store[:loader_loaded]).to eq(1)
+    end
+
+    it "registers config defaults" do
+      define_loader(:test_loader) do
+        def on_load
+          register_config_defaults(:my_option => true)
+        end
+      end
+      Appsignal::Loaders.load(:test_loader)
+
+      expect(Appsignal::Config.loader_defaults).to eq([[:test_loader, { :my_option => true }]])
+    end
+
+    it "does not load errors that aren't registered" do
+      logs =
+        capture_logs do
+          Appsignal::Loaders.load(:unknown_loader)
+        end
+
+      expect(logs).to contains_log(:warn, "No loader found with the name 'unknown_loader'.")
+    end
+
+    it "loads the loader file on load" do
+      expect(Appsignal::Loaders.registered?(:loader_stub)).to be_falsy
+      Appsignal::Loaders.load(:loader_stub)
+
+      expect(Appsignal::Loaders.registered?(:loader_stub)).to be_truthy
+    end
+
+    it "does not error when a loader has no on_load method" do
+      define_loader(:test_loader) do
+        # Do nothing
+      end
+      Appsignal::Loaders.load(:test_loader)
+    end
+
+    it "logs an error when an error occurs on load" do
+      define_loader(:test_loader) do
+        def on_load
+          raise ExampleStandardError, "uh oh"
+        end
+      end
+      logs =
+        capture_logs do
+          Appsignal::Loaders.load(:test_loader)
+        end
+
+      expect(logs).to contains_log(
+        :error,
+        "An error occurred while loading the 'test_loader' loader: ExampleStandardError: uh oh"
+      )
+    end
+  end
+
+  describe ".start" do
+    it "starts all loaded loaders" do
+      Appsignal::Testing.store[:loader_started] = 0
+      define_loader(:test_loader) do
+        def on_start
+          Appsignal::Testing.store[:loader_started] += 1
+        end
+      end
+      Appsignal::Loaders.load(:test_loader)
+      Appsignal::Loaders.start
+
+      expect(Appsignal::Testing.store[:loader_started]).to eq(1)
+    end
+
+    it "does not error when a loader has no on_start method" do
+      define_loader(:test_loader) do
+        # Do nothing
+      end
+      Appsignal::Loaders.load(:test_loader)
+      Appsignal::Loaders.start
+    end
+
+    it "logs an error when an error occurs on start" do
+      define_loader(:test_loader) do
+        def on_start
+          raise ExampleStandardError, "uh oh"
+        end
+      end
+      logs =
+        capture_logs do
+          Appsignal::Loaders.load(:test_loader)
+          Appsignal::Loaders.start
+        end
+
+      expect(logs).to contains_log(
+        :error,
+        "An error occurred while starting the 'test_loader' loader: ExampleStandardError: uh oh"
+      )
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ describe Appsignal::Probes::SidekiqProbe do
     let(:redis_hostname) { "localhost" }
     let(:expected_default_tags) { { :hostname => "localhost" } }
     before do
-      Appsignal.config = project_fixture_config
+      start_agent
 
       class SidekiqStats
         class << self

data/spec/lib/appsignal/probes_spec.rb

@@ -408,13 +408,14 @@ describe Appsignal::Probes do
       end
 
       context "logger" do
-        let(:log_stream) { std_stream }
-        let(:log) { log_contents(log_stream) }
+        before { start_agent }
 
-        around { |example| use_logger_with(log_stream) { example.run } }
         it "logs a deprecation message" do
-          silence { collection.register :my_probe, lambda {} }
-          expect(log).to contains_log :warn,
+          logs =
+            capture_logs do
+              silence { collection.register :my_probe, lambda {} }
+            end
+          expect(logs).to contains_log :warn,
             "The method 'Appsignal::Probes.probes.register' is deprecated. " \
               "Use 'Appsignal::Probes.register' instead."
         end

data/spec/lib/appsignal/rack/abstract_middleware_spec.rb

@@ -5,13 +5,14 @@ describe Appsignal::Rack::AbstractMiddleware do
     Rack::MockRequest.env_for(
       request_path,
       "REQUEST_METHOD" => "GET",
-      :params => { "page" => 2, "query" => "lorem" }
+      :params => { "page" => 2, "query" => "lorem" },
+      "rack.session" => { "session" => "data", "user_id" => 123 }
     )
   end
   let(:options) { {} }
   let(:middleware) { described_class.new(app, options) }
 
-  before(:context) { start_agent }
+  before { start_agent }
   around { |example| keep_transactions { example.run } }
 
   def make_request
@@ -247,7 +248,7 @@ describe Appsignal::Rack::AbstractMiddleware do
           end
         end
 
-        context "with fetching the request method raises an error" do
+        context "when fetching the request method raises an error" do
           class BrokenRequestMethodRequest < Rack::Request
             def request_method
               raise "uh oh!"
@@ -255,11 +256,16 @@ describe Appsignal::Rack::AbstractMiddleware do
           end
 
           let(:options) { { :request_class => BrokenRequestMethodRequest } }
+
           it "does not store the invalid HTTP request method" do
             env["REQUEST_METHOD"] = "FOO"
-            make_request
+            logs = capture_logs { make_request }
 
             expect(last_transaction).to_not include_metadata("method" => anything)
+            expect(logs).to contains_log(
+              :error,
+              "Exception while fetching the HTTP request method: RuntimeError: uh oh"
+            )
           end
         end
 
@@ -285,6 +291,35 @@ describe Appsignal::Rack::AbstractMiddleware do
             expect(last_transaction).to include_params("custom" => "param")
           end
         end
+
+        context "when fetching the request method raises an error" do
+          class BrokenRequestParamsRequest < Rack::Request
+            def params
+              raise "uh oh!"
+            end
+          end
+
+          let(:options) do
+            { :request_class => BrokenRequestParamsRequest, :params_method => :params }
+          end
+
+          it "does not store the invalid HTTP request method" do
+            logs = capture_logs { make_request }
+
+            expect(last_transaction).to_not include_params
+            expect(logs).to contains_log(
+              :error,
+              "Exception while fetching params " \
+                "from 'BrokenRequestParamsRequest#params': RuntimeError uh oh!"
+            )
+          end
+        end
+
+        it "sets session data" do
+          make_request
+
+          expect(last_transaction).to include_session_data("session" => "data", "user_id" => 123)
+        end
       end
 
       context "with queue start header" do
@@ -316,6 +351,10 @@ describe Appsignal::Rack::AbstractMiddleware do
         def filtered_params
           { "abc" => "123" }
         end
+
+        def session
+          { "data" => "value" }
+        end
       end
 
       context "with overridden request class and params method" do
@@ -328,6 +367,12 @@ describe Appsignal::Rack::AbstractMiddleware do
 
           expect(last_transaction).to include_params("abc" => "123")
         end
+
+        it "uses the overridden request class to fetch session data" do
+          make_request
+
+          expect(last_transaction).to include_session_data("data" => "value")
+        end
       end
 
       context "with parent instrumentation" do
@@ -355,11 +400,12 @@ describe Appsignal::Rack::AbstractMiddleware do
           expect(response_events).to eq(1)
         end
 
-        context "when response body is already a BodyWrapper subclass" do
+        context "when the response body is already instrumented" do
           let(:body) { Appsignal::Rack::BodyWrapper.wrap(["hello!"], transaction) }
           let(:app) { DummyApp.new { [200, {}, body] } }
 
           it "doesn't wrap the body again" do
+            env[Appsignal::Rack::APPSIGNAL_RESPONSE_INSTRUMENTED] = true
             _status, _headers, body = make_request
             expect(body).to eq(body)