appsignal 2.9.18.beta.1 → 2.10.6.beta.1

data/spec/lib/appsignal/hooks/action_cable_spec.rb

@@ -54,16 +54,12 @@ describe Appsignal::Hooks::ActionCableHook do
             .with(transaction_id, Appsignal::Transaction::ACTION_CABLE, kind_of(ActionDispatch::Request))
             .and_return(transaction)
           allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-          # Make sure sample data is added
-          expect(transaction.ext).to receive(:finish).and_return(true)
-          # Stub complete call, stops it from being cleared in the extension
-          # And allows us to call `#to_h` on it after it's been completed.
-          expect(transaction.ext).to receive(:complete)
 
           # Stub transmit call for subscribe/unsubscribe tests
           allow(connection).to receive(:websocket)
             .and_return(instance_double("ActionCable::Connection::WebSocket", :transmit => nil))
         end
+        around { |example| keep_transactions { example.run } }
 
         describe "#perform_action" do
           it "creates a transaction for an action" do

data/spec/lib/appsignal/hooks/rake_spec.rb

@@ -4,69 +4,71 @@ describe Appsignal::Hooks::RakeHook do
   let(:task) { Rake::Task.new("task:name", Rake::Application.new) }
   let(:arguments) { Rake::TaskArguments.new(["foo"], ["bar"]) }
   let(:generic_request) { Appsignal::Transaction::GenericRequest.new({}) }
-  before(:context) do
-    Appsignal.config = project_fixture_config
-    expect(Appsignal.active?).to be_truthy
-    Appsignal::Hooks.load_hooks
-  end
+  before(:context) { start_agent }
 
   describe "#execute" do
     context "without error" do
+      before { expect(Appsignal).to_not receive(:stop) }
+
+      def perform
+        task.execute(arguments)
+      end
+
       it "creates no transaction" do
-        expect(Appsignal::Transaction).to_not receive(:create)
+        expect(Appsignal::Transaction).to_not receive(:new)
+        expect { perform }.to_not(change { created_transactions })
       end
 
       it "calls the original task" do
-        expect(task).to receive(:execute_without_appsignal).with("foo")
+        expect(task).to receive(:execute_without_appsignal).with(arguments)
+        perform
       end
-
-      after { task.execute("foo") }
     end
 
     context "with error" do
       let(:error) { ExampleException }
-      let(:transaction) { background_job_transaction }
       before do
-        task.enhance { raise error }
-
-        expect(Appsignal::Transaction).to receive(:create).with(
-          kind_of(String),
-          Appsignal::Transaction::BACKGROUND_JOB,
-          kind_of(Appsignal::Transaction::GenericRequest)
-        ).and_return(transaction)
+        task.enhance { raise error, "my error message" }
+        # We don't call `and_call_original` here as we don't want AppSignal to
+        # stop and start for every spec.
+        expect(Appsignal).to receive(:stop).with("rake")
       end
 
-      it "sets the action" do
-        expect(transaction).to receive(:set_action).with("task:name")
-      end
-
-      it "sets the error" do
-        expect(transaction).to receive(:set_error).with(error)
+      def perform
+        keep_transactions do
+          expect { task.execute(arguments) }.to raise_error(error)
+        end
       end
 
-      it "completes the transaction and stops" do
-        expect(transaction).to receive(:complete).ordered
-        expect(Appsignal).to receive(:stop).with("rake").ordered
-      end
+      it "creates a background job transaction" do
+        perform
 
-      it "adds the task arguments to the request" do
-        expect(Appsignal::Transaction::GenericRequest).to receive(:new)
-          .with(:params => { :foo => "bar" })
-          .and_return(generic_request)
+        expect(last_transaction).to be_completed
+        expect(last_transaction.to_h).to include(
+          "id" => kind_of(String),
+          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+          "action" => "task:name",
+          "error" => {
+            "name" => "ExampleException",
+            "message" => "my error message",
+            "backtrace" => kind_of(String)
+          },
+          "sample_data" => hash_including(
+            "params" => { "foo" => "bar" }
+          )
+        )
       end
 
       context "when first argument is not a `Rake::TaskArguments`" do
         let(:arguments) { nil }
 
-        it "adds the first argument regardless" do
-          expect(Appsignal::Transaction::GenericRequest).to receive(:new)
-            .with(:params => nil)
-            .and_return(generic_request)
-        end
-      end
+        it "does not add the params to the transaction" do
+          perform
 
-      after do
-        expect { task.execute(arguments) }.to raise_error ExampleException
+          expect(last_transaction.to_h).to include(
+            "sample_data" => hash_excluding("params")
+          )
+        end
       end
     end
   end

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

@@ -38,28 +38,15 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
     }
   end
   let(:plugin) { Appsignal::Hooks::SidekiqPlugin.new }
-  let(:test_store) { {} }
   let(:log) { StringIO.new }
   before do
     start_agent
     Appsignal.logger = test_logger(log)
-
-    # Stub calls to extension, because that would remove the transaction
-    # from the extension.
-    allow_any_instance_of(Appsignal::Extension::Transaction).to receive(:finish).and_return(true)
-    allow_any_instance_of(Appsignal::Extension::Transaction).to receive(:complete)
-
-    # Stub removal of current transaction from current thread so we can fetch
-    # it later.
-    expect(Appsignal::Transaction).to receive(:clear_current_transaction!) do
-      transaction = Thread.current[:appsignal_transaction]
-      test_store[:transaction] = transaction if transaction
-    end
   end
+  around { |example| keep_transactions { example.run } }
   after :with_yaml_parse_error => false do
     expect(log_contents(log)).to_not contains_log(:warn, "Unable to load YAML")
   end
-  after { clear_current_transaction! }
 
   shared_examples "sidekiq metadata" do
     describe "internal Sidekiq job values" do
@@ -513,7 +500,7 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
   end
 
   def transaction
-    test_store[:transaction]
+    last_transaction
   end
 
   def expect_transaction_to_have_sidekiq_event(transaction_hash)

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

@@ -93,6 +93,16 @@ if DependencyHelper.grape_present?
             expect(transaction).to receive(:set_error).with(kind_of(ExampleException))
           end
 
+          context "with env['grape.skip_appsignal_error'] = true" do
+            before do
+              env["grape.skip_appsignal_error"] = true
+            end
+
+            it "does not add the error" do
+              expect(transaction).to_not receive(:set_error)
+            end
+          end
+
           after do
             expect { middleware.call(env) }.to raise_error ExampleException
           end

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

@@ -16,8 +16,8 @@ describe Object do
       context "when active" do
         let(:transaction) { http_request_transaction }
         before do
-          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
           Appsignal.config = project_fixture_config
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
         end
         after { Appsignal.config = nil }
 
@@ -137,9 +137,9 @@ describe Object do
       context "when active" do
         let(:transaction) { http_request_transaction }
         before do
+          Appsignal.config = project_fixture_config
           expect(Appsignal::Transaction).to receive(:current).at_least(:once)
             .and_return(transaction)
-          Appsignal.config = project_fixture_config
         end
         after { Appsignal.config = nil }
 

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

@@ -37,47 +37,30 @@ if DependencyHelper.que_present?
         end
       end
       let(:instance) { job.new(job_attrs) }
-      let(:transaction) do
-        Appsignal::Transaction.new(
-          SecureRandom.uuid,
-          Appsignal::Transaction::BACKGROUND_JOB,
-          Appsignal::Transaction::GenericRequest.new(env)
-        )
-      end
 
       before do
         allow(Que).to receive(:execute)
 
         start_agent
         expect(Appsignal.active?).to be_truthy
-        transaction
-
-        expect(Appsignal::Transaction).to receive(:create)
-          .with(
-            kind_of(String),
-            Appsignal::Transaction::BACKGROUND_JOB,
-            kind_of(Appsignal::Transaction::GenericRequest)
-          ).and_return(transaction)
-        allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-        expect(transaction.ext).to receive(:finish).and_return(true)
-        expect(transaction.ext).to receive(:complete)
       end
-
-      subject { transaction.to_h }
+      around { |example| keep_transactions { example.run } }
 
       context "success" do
         it "creates a transaction for a job" do
           expect do
             instance._run
-          end.to_not raise_exception
+          end.to change { created_transactions.length }.by(1)
 
-          expect(subject).to include(
+          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(subject["error"]).to be_nil
-          expect(subject["events"].first).to include(
+          expect(transaction_hash["error"]).to be_nil
+          expect(transaction_hash["events"].first).to include(
             "allocation_count" => kind_of(Integer),
             "body" => "",
             "body_format" => Appsignal::EventFormatter::DEFAULT,
@@ -91,7 +74,7 @@ if DependencyHelper.que_present?
             "name" => "perform_job.que",
             "title" => ""
           )
-          expect(subject["sample_data"]).to include(
+          expect(transaction_hash["sample_data"]).to include(
             "params" => %w[1 birds],
             "metadata" => {
               "attempts" => 0,
@@ -107,24 +90,28 @@ if DependencyHelper.que_present?
       context "with exception" do
         let(:error) { ExampleException.new("oh no!") }
 
-        it "should report exceptions and re-raise them" do
+        it "reports exceptions and re-raise them" do
           allow(instance).to receive(:run).and_raise(error)
 
           expect do
-            instance._run
-          end.to raise_error(ExampleException)
-
-          expect(subject).to include(
+            expect do
+              instance._run
+            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(subject["error"]).to include(
+          expect(transaction_hash["error"]).to include(
             "backtrace" => kind_of(String),
             "name" => error.class.name,
             "message" => error.message
           )
-          expect(subject["sample_data"]).to include(
+          expect(transaction_hash["sample_data"]).to include(
             "params" => %w[1 birds],
             "metadata" => {
               "attempts" => 0,
@@ -140,24 +127,24 @@ if DependencyHelper.que_present?
       context "with error" do
         let(:error) { ExampleStandardError.new("oh no!") }
 
-        it "should report errors and not re-raise them" do
+        it "reports errors and not re-raise them" do
           allow(instance).to receive(:run).and_raise(error)
 
-          expect do
-            instance._run
-          end.to_not raise_error
+          expect { instance._run }.to change { created_transactions.length }.by(1)
 
-          expect(subject).to include(
+          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(subject["error"]).to include(
+          expect(transaction_hash["error"]).to include(
             "backtrace" => kind_of(String),
             "name" => error.class.name,
             "message" => error.message
           )
-          expect(subject["sample_data"]).to include(
+          expect(transaction_hash["sample_data"]).to include(
             "params" => %w[1 birds],
             "metadata" => {
               "attempts" => 0,

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

@@ -17,67 +17,129 @@ if DependencyHelper.resque_present? && DependencyHelper.active_job_present?
       end
     end
 
-    it "wraps it in a transaction with the correct params" do
-      expect(Appsignal).to receive(:monitor_single_transaction).with(
-        "perform_job.resque",
-        :class  => "TestActiveJob",
-        :method => "perform",
-        :params => ["argument"],
-        :metadata => {
-          :id    => kind_of(String),
-          :queue => "default"
-        }
-      )
+    def perform
+      keep_transactions do
+        job.perform_now
+      end
     end
 
-    context "with complex arguments" do
-      let(:args) do
-        {
-          :foo => "Foo",
-          :bar => "Bar"
-        }
+    context "without error" do
+      it "creates a new transaction" do
+        expect { perform }.to change { created_transactions.length }.by(1)
+
+        expect(last_transaction.to_h).to include(
+          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+          "action" => "TestActiveJob#perform",
+          "error" => nil,
+          "events" => [
+            hash_including(
+              "name" => "perform_job.resque",
+              "title" => "",
+              "body" => "",
+              "body_format" => Appsignal::EventFormatter::DEFAULT,
+              "count" => 1,
+              "duration" => kind_of(Float)
+            )
+          ],
+          "sample_data" => hash_including(
+            "params" => ["argument"],
+            "metadata" => {
+              "id" => kind_of(String),
+              "queue" => "default"
+            }
+          )
+        )
       end
+    end
+
+    context "with error" do
+      let(:job) do
+        class BrokenTestActiveJob < ActiveJob::Base
+          include Appsignal::Integrations::ResqueActiveJobPlugin
 
-      it "truncates large argument values" do
-        expect(Appsignal).to receive(:monitor_single_transaction).with(
-          "perform_job.resque",
-          :class  => "TestActiveJob",
-          :method => "perform",
-          :params => [
+          def perform(_)
+            raise ExampleException, "my error message"
+          end
+        end
+
+        BrokenTestActiveJob.new(args)
+      end
+
+      it "creates a new transaction with an error" do
+        expect do
+          expect { perform }.to raise_error(ExampleException, "my error message")
+        end.to change { created_transactions.length }.by(1)
+
+        expect(last_transaction.to_h).to include(
+          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+          "action" => "BrokenTestActiveJob#perform",
+          "error" => {
+            "name" => "ExampleException",
+            "message" => "my error message",
+            "backtrace" => kind_of(String)
+          },
+          "sample_data" => hash_including(
+            "params" => ["argument"],
+            "metadata" => {
+              "id" => kind_of(String),
+              "queue" => "default"
+            }
+          )
+        )
+      end
+    end
+
+    context "with complex arguments" do
+      context "with too long values" do
+        let(:args) do
+          {
             :foo => "Foo",
-            :bar => "Bar"
-          ],
-          :metadata => {
-            :id    => kind_of(String),
-            :queue => "default"
+            :bar => "a" * 2001
           }
-        )
+        end
+
+        it "truncates large argument values" do
+          perform
+          expect(last_transaction.to_h).to include(
+            "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+            "action" => "TestActiveJob#perform",
+            "error" => nil,
+            "sample_data" => hash_including(
+              "params" => ["foo" => "Foo", "bar" => "#{"a" * 2000}..."],
+              "metadata" => {
+                "id" => kind_of(String),
+                "queue" => "default"
+              }
+            )
+          )
+        end
       end
 
       context "with parameter filtering" do
-        before do
-          Appsignal.config = project_fixture_config("production")
-          Appsignal.config[:filter_parameters] = ["foo"]
+        let(:args) do
+          {
+            :foo => "Foo",
+            :bar => "Bar"
+          }
         end
+        before { Appsignal.config[:filter_parameters] = ["foo"] }
 
         it "filters selected arguments" do
-          expect(Appsignal).to receive(:monitor_single_transaction).with(
-            "perform_job.resque",
-            :class  => "TestActiveJob",
-            :method => "perform",
-            :params => [
-              :foo => "[FILTERED]",
-              :bar => "Bar"
-            ],
-            :metadata => {
-              :id    => kind_of(String),
-              :queue => "default"
-            }
+          perform
+          expect(last_transaction.to_h).to include(
+            "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+            "action" => "TestActiveJob#perform",
+            "error" => nil,
+            "sample_data" => hash_including(
+              "params" => ["foo" => "[FILTERED]", "bar" => "Bar"],
+              "metadata" => {
+                "id" => kind_of(String),
+                "queue" => "default"
+              }
+            )
           )
         end
       end
     end
-
-    after { job.perform_now }
   end
 end