appsignal 3.9.2-java → 3.10.0-java

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

@@ -2,51 +2,134 @@ if DependencyHelper.padrino_present?
   describe "Padrino integration" do
     require "appsignal/integrations/padrino"
 
-    before do
-      allow(Appsignal).to receive(:active?).and_return(true)
-      allow(Appsignal).to receive(:start).and_return(true)
-      allow(Appsignal).to receive(:start_logger).and_return(true)
-    end
-
     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
-
-      it "starts the logger on init" do
-        expect(Appsignal).to receive(:start_logger)
+      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
-      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
-          Appsignal::Integrations::PadrinoPlugin.init
+        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)
+            expect(Padrino.env.to_s).to eq("test")
+            expect(Appsignal.config.env).to eq(Padrino.env.to_s)
+          end
         end
       end
 
-      after { Appsignal::Integrations::PadrinoPlugin.init }
+      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(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
     end
 
     describe Padrino::Routing::InstanceMethods do
@@ -59,21 +142,10 @@ if DependencyHelper.padrino_present?
       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(:transaction) do
-          instance_double "Appsignal::Transaction",
-            :set_http_or_background_action => nil,
-            :set_http_or_background_queue_start => nil,
-            :set_metadata => nil,
-            :set_action => nil,
-            :set_action_if_nil => nil,
-            :set_error => nil,
-            :start_event => nil,
-            :finish_event => nil,
-            :complete => nil
-        end
-        let(:request_kind) { kind_of(Sinatra::Request) }
         let(:env) do
           {
             "REQUEST_METHOD" => "GET",
@@ -90,10 +162,6 @@ if DependencyHelper.padrino_present?
           end
         end
         let(:response) { app.call(env) }
-        before do
-          allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
-          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-        end
 
         RSpec::Matchers.define :match_response do |expected_status, expected_content|
           match do |response|
@@ -108,47 +176,30 @@ if DependencyHelper.padrino_present?
           end
         end
 
-        def expect_a_transaction_to_be_created
-          expect(Appsignal::Transaction).to receive(:create).with(
-            kind_of(String),
-            Appsignal::Transaction::HTTP_REQUEST,
-            request_kind
-          ).and_return(transaction)
-
-          expect(Appsignal).to receive(:instrument)
-            .at_least(:once)
-            .with("process_action.padrino")
-            .and_call_original
-          expect(transaction).to receive(:set_metadata).with("path", path)
-          expect(transaction).to receive(:set_metadata).with("method", "GET")
-          expect(transaction).to receive(:complete)
-        end
-
-        def expect_no_transaction_to_be_created
-          expect(Appsignal::Transaction).to_not receive(:create)
-          expect(Appsignal).to_not receive(:instrument)
-        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" } } }
-          after { expect(response).to match_response(200, "content") }
 
           it "does not instrument the request" do
-            expect_no_transaction_to_be_created
+            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_a_transaction_to_be_created
-              # Uses path for action name
-              expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp#unknown")
               expect(response).to match_response(404, /^GET /404/)
+              expect(last_transaction).to have_action("PadrinoTestApp#unknown")
             end
           end
 
@@ -158,10 +209,10 @@ if DependencyHelper.padrino_present?
               env["sinatra.static_file"] = true
               app.controllers { get(:static) { "Static!" } }
             end
-            after { expect(response).to match_response(200, "Static!") }
 
             it "does not instrument the request" do
-              expect_no_transaction_to_be_created
+              expect(response).to match_response(200, "Static!")
+              expect(last_transaction).to_not have_action
             end
           end
 
@@ -172,12 +223,10 @@ if DependencyHelper.padrino_present?
               allow_any_instance_of(Sinatra::Request).to receive(:action).and_return(nil)
               app.controllers { get(:my_original_path, :with => :id) { "content" } }
             end
-            after { expect(response).to match_response(200, "content") }
 
             it "falls back on Sinatra::Request#route_obj.original_path" do
-              expect_a_transaction_to_be_created
-              expect(transaction)
-                .to receive(:set_action_if_nil).with("PadrinoTestApp:/my_original_path/:id")
+              expect(response).to match_response(200, "content")
+              expect(last_transaction).to have_action("PadrinoTestApp:/my_original_path/:id")
             end
           end
 
@@ -188,117 +237,95 @@ if DependencyHelper.padrino_present?
               allow_any_instance_of(Sinatra::Request).to receive(:route_obj).and_return(nil)
               app.controllers { get(:my_original_path) { "content" } }
             end
-            after { expect(response).to match_response(200, "content") }
 
             it "falls back on app name" do
-              expect_a_transaction_to_be_created
-              expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp#unknown")
+              expect(response).to match_response(200, "content")
+              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 } }
-                expect_a_transaction_to_be_created
-              end
-              after do
-                expect { response }.to raise_error(ExampleException)
-              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(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:#exception")
+            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
 
-              it "sets the error on the transaction" do
-                expect(transaction).to receive(:set_error).with(ExampleException)
+              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 "without an exception in the controller" do
-              let(:path) { "/" }
-              after { expect(response).to match_response(200, "content") }
-
-              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
-                    expect_a_transaction_to_be_created
-                    expect(transaction).to receive(:set_action_if_nil).with("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
-                    expect_a_transaction_to_be_created
-                    expect(transaction).to receive(:set_action_if_nil).with("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
-                    expect_a_transaction_to_be_created
-                    expect(transaction).to receive(:set_action_if_nil).with("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
-                    expect_a_transaction_to_be_created
-                    expect(transaction).to receive(:set_action_if_nil).with("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
-                    expect_a_transaction_to_be_created
-                    expect(transaction).to receive(:set_action_if_nil)
-                      .with("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
-                    expect_a_transaction_to_be_created
-                    expect(transaction).to receive(:set_action_if_nil)
-                      .with("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/que_spec.rb

@@ -53,38 +53,27 @@ if DependencyHelper.que_present?
             perform_que_job(instance)
           end.to change { created_transactions.length }.by(1)
 
-          expect(last_transaction).to be_completed
-          transaction_hash = last_transaction.to_h
-          expect(transaction_hash).to include(
-            "action" => "MyQueJob#run",
-            "id" => instance_of(String),
-            "namespace" => Appsignal::Transaction::BACKGROUND_JOB
-          )
-          expect(transaction_hash["error"]).to be_nil
-          expect(transaction_hash["events"].first).to include(
-            "allocation_count" => kind_of(Integer),
+          transaction = last_transaction
+          expect(transaction).to have_id
+          expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+          expect(transaction).to have_action("MyQueJob#run")
+          expect(transaction).to_not have_error
+          expect(transaction).to include_event(
             "body" => "",
             "body_format" => Appsignal::EventFormatter::DEFAULT,
-            "child_allocation_count" => kind_of(Integer),
-            "child_duration" => kind_of(Float),
-            "child_gc_duration" => kind_of(Float),
             "count" => 1,
-            "gc_duration" => kind_of(Float),
-            "start" => kind_of(Float),
-            "duration" => kind_of(Float),
             "name" => "perform_job.que",
             "title" => ""
           )
-          expect(transaction_hash["sample_data"]).to include(
-            "params" => %w[1 birds],
-            "metadata" => {
-              "attempts" => 0,
-              "id" => 123,
-              "priority" => 100,
-              "queue" => "dfl",
-              "run_at" => fixed_time.to_s
-            }
+          expect(transaction).to include_params(%w[1 birds])
+          expect(transaction).to include_sample_metadata(
+            "attempts" => 0,
+            "id" => 123,
+            "priority" => 100,
+            "queue" => "dfl",
+            "run_at" => fixed_time.to_s
           )
+          expect(transaction).to be_completed
         end
       end
 
@@ -100,28 +89,20 @@ if DependencyHelper.que_present?
             end.to raise_error(ExampleException)
           end.to change { created_transactions.length }.by(1)
 
-          expect(last_transaction).to be_completed
-          transaction_hash = last_transaction.to_h
-          expect(transaction_hash).to include(
-            "action" => "MyQueJob#run",
-            "id" => instance_of(String),
-            "namespace" => Appsignal::Transaction::BACKGROUND_JOB
-          )
-          expect(transaction_hash["error"]).to include(
-            "backtrace" => kind_of(String),
-            "name" => error.class.name,
-            "message" => error.message
-          )
-          expect(transaction_hash["sample_data"]).to include(
-            "params" => %w[1 birds],
-            "metadata" => {
-              "attempts" => 0,
-              "id" => 123,
-              "priority" => 100,
-              "queue" => "dfl",
-              "run_at" => fixed_time.to_s
-            }
+          transaction = last_transaction
+          expect(transaction).to have_id
+          expect(transaction).to have_action("MyQueJob#run")
+          expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+          expect(transaction).to have_error(error.class.name, error.message)
+          expect(transaction).to include_params(%w[1 birds])
+          expect(transaction).to include_sample_metadata(
+            "attempts" => 0,
+            "id" => 123,
+            "priority" => 100,
+            "queue" => "dfl",
+            "run_at" => fixed_time.to_s
           )
+          expect(transaction).to be_completed
         end
       end
 
@@ -133,28 +114,20 @@ if DependencyHelper.que_present?
 
           expect { perform_que_job(instance) }.to change { created_transactions.length }.by(1)
 
-          expect(last_transaction).to be_completed
-          transaction_hash = last_transaction.to_h
-          expect(transaction_hash).to include(
-            "action" => "MyQueJob#run",
-            "id" => instance_of(String),
-            "namespace" => Appsignal::Transaction::BACKGROUND_JOB
-          )
-          expect(transaction_hash["error"]).to include(
-            "backtrace" => kind_of(String),
-            "name" => error.class.name,
-            "message" => error.message
-          )
-          expect(transaction_hash["sample_data"]).to include(
-            "params" => %w[1 birds],
-            "metadata" => {
-              "attempts" => 0,
-              "id" => 123,
-              "priority" => 100,
-              "queue" => "dfl",
-              "run_at" => fixed_time.to_s
-            }
+          transaction = last_transaction
+          expect(transaction).to have_id
+          expect(transaction).to have_action("MyQueJob#run")
+          expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+          expect(transaction).to have_error(error.class.name, error.message)
+          expect(transaction).to include_params(%w[1 birds])
+          expect(transaction).to include_sample_metadata(
+            "attempts" => 0,
+            "id" => 123,
+            "priority" => 100,
+            "queue" => "dfl",
+            "run_at" => fixed_time.to_s
           )
+          expect(transaction).to be_completed
         end
       end
 
@@ -170,9 +143,9 @@ if DependencyHelper.que_present?
         it "uses the custom action" do
           perform_que_job(instance)
 
-          expect(last_transaction).to be_completed
-          transaction_hash = last_transaction.to_h
-          expect(transaction_hash).to include("action" => "MyCustomJob#perform")
+          transaction = last_transaction
+          expect(transaction).to have_action("MyCustomJob#perform")
+          expect(transaction).to be_completed
         end
       end
     end