appsignal 4.0.6 → 4.0.8

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

@@ -1,136 +0,0 @@
-if DependencyHelper.webmachine_present?
-  require "appsignal/integrations/webmachine"
-
-  class Response
-    attr_accessor :code
-
-    def body
-      ""
-    end
-
-    def headers
-      {}
-    end
-  end
-
-  describe Appsignal::Integrations::WebmachineIntegration do
-    let(:request) do
-      Webmachine::Request.new(
-        "GET",
-        "http://google.com:80/foo?param1=value1&param2=value2",
-        {
-          "REQUEST_METHOD" => "GET",
-          "PATH_INFO" => "/some/path",
-          "ignored_header" => "something"
-        },
-        nil
-      )
-    end
-    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
-
-        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
-      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("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
-        fsm.run
-        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 "sets the headers" do
-        fsm.run
-        expect(last_transaction).to include_environment(
-          "REQUEST_METHOD" => "GET",
-          "PATH_INFO" => "/some/path"
-        )
-      end
-
-      it "closes the transaction" do
-        fsm.run
-        expect(last_transaction).to be_completed
-        expect(current_transaction?).to be_falsy
-      end
-
-      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
-
-    describe "#handle_exceptions" do
-      let(:error) { ExampleException.new("error message") }
-      let(:transaction) { http_request_transaction }
-
-      it "tracks the error" do
-        with_current_transaction(transaction) do
-          fsm.send(:handle_exceptions) { raise error }
-        end
-
-        expect(last_transaction).to have_error("ExampleException", "error message")
-      end
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-if DependencyHelper.grape_present?
-  describe "Appsignal::Loaders::PadrinoLoader" do
-    describe "#on_load" do
-      it "ensures the Grape middleware is loaded" do
-        load_loader(:grape)
-
-        # Calling this doesn't raise a NameError
-        Appsignal::Rack::GrapeMiddleware
-      end
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-if DependencyHelper.hanami_present?
-  describe "Appsignal::Loaders::HanamiLoader" do
-    describe "#on_load" do
-      it "registers Hanami default config" do
-        load_loader(:hanami)
-
-        expect(Appsignal::Config.loader_defaults).to include(
-          :name => :hanami,
-          :root_path => Dir.pwd,
-          :env => :test,
-          :options => {}
-        )
-      end
-    end
-
-    describe "#on_start" do
-      before do
-        allow(::Hanami::Action).to receive(:prepend)
-        load_loader(:hanami)
-        start_loader(:hanami)
-      end
-      after { uninstall_hanami_middleware }
-
-      def uninstall_hanami_middleware
-        middleware_stack = ::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX]
-        middleware_stack.delete_if do |middleware|
-          middleware.first == Appsignal::Rack::HanamiMiddleware ||
-            middleware.first == Rack::Events
-        end
-      end
-
-      it "adds the instrumentation middleware to Sinatra::Base" do
-        expect(::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX])
-          .to include(
-            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], *hanami_middleware_options],
-            [Appsignal::Rack::HanamiMiddleware, [], *hanami_middleware_options]
-          )
-      end
-
-      it "prepends the integration to Hanami::Action" do
-        expect(::Hanami::Action)
-          .to have_received(:prepend).with(Appsignal::Loaders::HanamiLoader::HanamiIntegration)
-      end
-
-      def hanami_middleware_options
-        if DependencyHelper.hanami2_1_present?
-          [{}, nil]
-        else
-          [nil]
-        end
-      end
-    end
-
-    describe "Appsignal::Loaders::HanamiLoader::HanamiIntegration" do
-      let(:transaction) { http_request_transaction }
-      let(:app) { HanamiApp::Actions::Books::Index }
-      around { |example| keep_transactions { example.run } }
-      before do
-        expect(::Hanami.app.config).to receive(:root).and_return(project_fixture_path)
-        Appsignal.load(:hanami)
-        start_agent
-      end
-
-      def make_request(env)
-        action = app.new
-        action.call(env)
-      end
-
-      describe "#call" do
-        context "without an active transaction" do
-          let(:env) { {} }
-
-          it "does not set the action name" do
-            make_request(env)
-
-            expect(transaction).to_not have_action
-          end
-        end
-
-        context "with an active transaction" do
-          let(:env) { { Appsignal::Rack::APPSIGNAL_TRANSACTION => transaction } }
-
-          it "sets action name on the transaction" do
-            make_request(env)
-
-            expect(transaction).to have_action("HanamiApp::Actions::Books::Index")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,273 +0,0 @@
-if DependencyHelper.padrino_present?
-  describe "Appsignal::Loaders::PadrinoLoader" do
-    describe "#on_load" do
-      it "registers Padrino default config" do
-        load_loader(:padrino)
-
-        expect(Appsignal::Config.loader_defaults).to include(
-          :name => :padrino,
-          :root_path => Padrino.mounted_root,
-          :env => :test,
-          :options => {}
-        )
-      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 } }
-
-      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

@@ -1,44 +0,0 @@
-if DependencyHelper.sinatra_present?
-  describe "Appsignal::Loaders::SinatraLoader" do
-    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(
-          :name => :sinatra,
-          :root_path => "/some/path",
-          :env => :test,
-          :options => {}
-        )
-      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

@@ -1,144 +0,0 @@
-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([
-        {
-          :name => :test_loader,
-          :env => nil,
-          :root_path => nil,
-          :options => { :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