appsignal 3.9.3 → 3.11.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/que_spec.rb

@@ -39,7 +39,6 @@ if DependencyHelper.que_present?
         allow(Que).to receive(:execute)
 
         start_agent
-        expect(Appsignal.active?).to be_truthy
       end
       around { |example| keep_transactions { example.run } }
 
@@ -66,7 +65,7 @@ if DependencyHelper.que_present?
             "title" => ""
           )
           expect(transaction).to include_params(%w[1 birds])
-          expect(transaction).to include_sample_metadata(
+          expect(transaction).to include_tags(
             "attempts" => 0,
             "id" => 123,
             "priority" => 100,
@@ -95,7 +94,7 @@ if DependencyHelper.que_present?
           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(
+          expect(transaction).to include_tags(
             "attempts" => 0,
             "id" => 123,
             "priority" => 100,
@@ -120,7 +119,7 @@ if DependencyHelper.que_present?
           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(
+          expect(transaction).to include_tags(
             "attempts" => 0,
             "id" => 123,
             "priority" => 100,

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

@@ -0,0 +1,167 @@
+require "appsignal/integrations/shoryuken"
+
+describe Appsignal::Integrations::ShoryukenMiddleware do
+  class DemoShoryukenWorker
+  end
+
+  let(:time) { "2010-01-01 10:01:00UTC" }
+  let(:worker_instance) { DemoShoryukenWorker.new }
+  let(:queue) { "some-funky-queue-name" }
+  let(:sqs_msg) { double(:message_id => "msg1", :attributes => {}) }
+  let(:body) { {} }
+  before { start_agent }
+  around { |example| keep_transactions { example.run } }
+
+  def perform_shoryuken_job(&block)
+    block ||= lambda {}
+    Timecop.freeze(Time.parse(time)) do
+      described_class.new.call(
+        worker_instance,
+        queue,
+        sqs_msg,
+        body,
+        &block
+      )
+    end
+  end
+
+  context "with a performance call" do
+    let(:sent_timestamp) { Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 }
+    let(:sqs_msg) do
+      double(:message_id => "msg1", :attributes => { "SentTimestamp" => sent_timestamp })
+    end
+
+    context "with complex argument" do
+      let(:body) { { :foo => "Foo", :bar => "Bar" } }
+
+      it "wraps the job in a transaction with the correct params" do
+        expect { perform_shoryuken_job }.to change { created_transactions.length }.by(1)
+
+        transaction = last_transaction
+        expect(transaction).to have_id
+        expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+        expect(transaction).to have_action("DemoShoryukenWorker#perform")
+        expect(transaction).to_not have_error
+        expect(transaction).to include_event(
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "count" => 1,
+          "name" => "perform_job.shoryuken",
+          "title" => ""
+        )
+        expect(transaction).to include_params("foo" => "Foo", "bar" => "Bar")
+        expect(transaction).to include_tags(
+          "message_id" => "msg1",
+          "queue" => queue,
+          "SentTimestamp" => sent_timestamp
+        )
+        expect(transaction).to have_queue_start(sent_timestamp)
+        expect(transaction).to be_completed
+      end
+
+      context "with parameter filtering" do
+        before do
+          Appsignal.config = project_fixture_config("production")
+          Appsignal.config[:filter_parameters] = ["foo"]
+        end
+
+        it "filters selected arguments" do
+          perform_shoryuken_job
+
+          expect(last_transaction).to include_params("foo" => "[FILTERED]", "bar" => "Bar")
+        end
+      end
+    end
+
+    context "with a string as an argument" do
+      let(:body) { "foo bar" }
+
+      it "handles string arguments" do
+        perform_shoryuken_job
+
+        expect(last_transaction).to include_params("params" => body)
+      end
+    end
+
+    context "with primitive type as argument" do
+      let(:body) { 1 }
+
+      it "handles primitive types as arguments" do
+        perform_shoryuken_job
+
+        expect(last_transaction).to include_params("params" => body)
+      end
+    end
+  end
+
+  context "with exception" do
+    it "sets the exception on the transaction" do
+      expect do
+        expect do
+          perform_shoryuken_job { raise ExampleException, "error message" }
+        end.to raise_error(ExampleException)
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to have_id
+      expect(transaction).to have_action("DemoShoryukenWorker#perform")
+      expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+      expect(transaction).to have_error("ExampleException", "error message")
+      expect(transaction).to be_completed
+    end
+  end
+
+  context "with batched jobs" do
+    let(:sqs_msg) do
+      [
+        double(
+          :message_id => "msg2",
+          :attributes => {
+            "SentTimestamp" => (Time.parse("1976-11-18 01:00:00UTC").to_i * 1000).to_s
+          }
+        ),
+        double(
+          :message_id => "msg1",
+          :attributes => { "SentTimestamp" => sent_timestamp.to_s }
+        )
+      ]
+    end
+    let(:body) do
+      [
+        "foo bar",
+        { :id => "123", :foo => "Foo", :bar => "Bar" }
+      ]
+    end
+    let(:sent_timestamp) { Time.parse("1976-11-18 01:00:00UTC").to_i * 1000 }
+
+    it "creates a transaction for the batch" do
+      expect do
+        perform_shoryuken_job {} # rubocop:disable Lint/EmptyBlock
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to have_id
+      expect(transaction).to have_action("DemoShoryukenWorker#perform")
+      expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+      expect(transaction).to_not have_error
+      expect(transaction).to include_event(
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::DEFAULT,
+        "count" => 1,
+        "name" => "perform_job.shoryuken",
+        "title" => ""
+      )
+      expect(transaction).to include_params(
+        "msg2" => "foo bar",
+        "msg1" => { "id" => "123", "foo" => "Foo", "bar" => "Bar" }
+      )
+      expect(transaction).to include_tags(
+        "batch" => true,
+        "queue" => "some-funky-queue-name",
+        "SentTimestamp" => sent_timestamp.to_s # Earliest/oldest timestamp from messages
+      )
+      # Queue time based on earliest/oldest timestamp from messages
+      expect(transaction).to have_queue_start(sent_timestamp)
+    end
+  end
+end

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

@@ -362,7 +362,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
         perform_sidekiq_job { raise error, "uh oh" }
       end.to raise_error(error)
 
-      expect(transaction).to have_id(jid)
+      expect(transaction).to have_id
       expect(transaction).to have_namespace(namespace)
       expect(transaction).to have_action("TestClass#perform")
       expect(transaction).to have_error("ExampleException", "uh oh")
@@ -373,7 +373,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
       )
       expect(transaction).to_not include_environment
       expect(transaction).to include_params(expected_args)
-      expect(transaction).to_not include_tags
+      expect(transaction).to include_tags("request_id" => jid)
       expect(transaction).to_not include_breadcrumbs
       expect_transaction_to_have_sidekiq_event(transaction)
     end
@@ -418,11 +418,11 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
         .with("sidekiq_queue_job_count", 1, { :queue => "default", :status => :processed })
       perform_sidekiq_job
 
-      expect(transaction).to have_id(jid)
+      expect(transaction).to have_id
       expect(transaction).to have_namespace(namespace)
       expect(transaction).to have_action("TestClass#perform")
       expect(transaction).to_not have_error
-      expect(transaction).to_not include_tags
+      expect(transaction).to include_tags("request_id" => jid)
       expect(transaction).to_not include_environment
       expect(transaction).to_not include_breadcrumbs
       expect(transaction).to_not include_params(expected_args)

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