appsignal 3.11.0-java → 3.12.1-java

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

@@ -1,110 +1,15 @@
-if DependencyHelper.sinatra_present?
-  require "appsignal/integrations/sinatra"
-
-  def install_sinatra_integration
-    load File.expand_path("lib/appsignal/integrations/sinatra.rb", project_dir)
-  end
-
-  # "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|
-      expected_middleware.include?(middleware.first)
-    end
-  end
-
+if DependencyHelper.padrino_present?
   describe "Sinatra integration" do
-    before do
-      Appsignal.config = nil
-    end
-    after { uninstall_sinatra_integration }
-
-    context "when active" do
-      before { allow(Appsignal).to receive(:active?).and_return(true) }
-
-      it "does not start AppSignal again" do
-        expect(Appsignal::Config).to_not receive(:new)
-        expect(Appsignal).to_not receive(:start)
-        install_sinatra_integration
-      end
-
-      it "adds the instrumentation middleware to Sinatra::Base" do
-        install_sinatra_integration
-        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
-
-    context "when not active" do
-      context "Appsignal.internal_logger" do
-        subject { Appsignal.internal_logger }
-
-        it "sets a logger" do
-          install_sinatra_integration
-          is_expected.to be_a Logger
-        end
-      end
-
-      describe "middleware" do
-        context "when AppSignal is not active" do
-          it "does not add the instrumentation middleware to Sinatra::Base" do
-            install_sinatra_integration
-            middlewares = Sinatra::Base.middleware.to_a
-            expect(middlewares).to_not include(
-              [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
-            )
-            expect(middlewares).to_not include(
-              [Rack::Events, [Appsignal::Rack::EventHandler], nil]
-            )
-          end
-        end
-
-        context "when the new AppSignal config is active" do
-          it "adds the instrumentation middleware to Sinatra::Base" do
-            ENV["APPSIGNAL_APP_NAME"] = "My Sinatra app name"
-            ENV["APPSIGNAL_APP_ENV"] = "test"
-            ENV["APPSIGNAL_PUSH_API_KEY"] = "my-key"
-
-            install_sinatra_integration
-            middlewares = Sinatra::Base.middleware.to_a
-            expect(middlewares).to include(
-              [Rack::Events, [[Appsignal::Rack::EventHandler]], nil],
-              [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
-            )
-          end
-        end
-      end
-
-      describe "environment" do
-        subject { Appsignal.config.env }
-
-        context "without APPSIGNAL_APP_ENV" do
-          before { install_sinatra_integration }
-
-          it "uses the app environment" do
-            expect(subject).to eq("test")
-          end
-        end
+    it "loads the Sinatra loader" do
+      ENV["APPSIGNAL_APP_NAME"] = "test/sinatra"
+      ENV["APPSIGNAL_PUSH_API_KEY"] = "test-key"
 
-        context "with APPSIGNAL_APP_ENV" do
-          before do
-            ENV["APPSIGNAL_APP_ENV"] = "env-staging"
-            install_sinatra_integration
-          end
+      require "appsignal/integrations/sinatra"
 
-          it "uses the environment variable" do
-            expect(subject).to eq("env-staging")
-          end
-        end
-      end
+      expect(Appsignal::Loaders.instances).to include(
+        :sinatra => kind_of(Appsignal::Loaders::SinatraLoader)
+      )
+      expect(Appsignal.active?).to be(true)
     end
   end
 end

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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,95 @@
+if DependencyHelper.hanami_present?
+  describe "Appsignal::Loaders::HanamiLoader" do
+    before { Appsignal.config = nil }
+
+    describe "#on_load" do
+      it "registers Hanami default config" do
+        load_loader(:hanami)
+
+        expect(Appsignal::Config.loader_defaults).to include([
+          :hanami,
+          {
+            :env => :test,
+            :root_path => Dir.pwd
+          }
+        ])
+      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

@@ -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