appsignal 2.9.17 → 2.10.0

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

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

@@ -18,65 +18,66 @@ if DependencyHelper.resque_present?
           extend Appsignal::Integrations::ResquePlugin
 
           def self.perform
-            raise ExampleException
+            raise ExampleException, "my error message"
           end
         end
       end
 
       describe :around_perform_resque_plugin do
-        let(:transaction) { Appsignal::Transaction.new("1", "background", {}, {}) }
         let(:job) { ::Resque::Job.new("default", "class" => "TestJob") }
-        before do
-          allow(transaction).to receive(:complete).and_return(true)
-          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-          expect(Appsignal).to receive(:stop)
-        end
+        before { expect(Appsignal).to receive(:stop) }
 
         context "without exception" do
           it "creates a new transaction" do
-            expect(Appsignal::Transaction).to receive(:create).and_return(transaction)
-          end
+            expect do
+              keep_transactions { job.perform }
+            end.to change { created_transactions.length }.by(1)
 
-          it "wraps it in a transaction with the correct params" do
-            expect(Appsignal).to receive(:monitor_transaction).with(
-              "perform_job.resque",
-              :class => "TestJob",
-              :method => "perform"
+            expect(last_transaction).to be_completed
+            expect(last_transaction.to_h).to include(
+              "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+              "action" => "TestJob#perform",
+              "error" => nil,
+              "events" => [
+                hash_including(
+                  "name" => "perform_job.resque",
+                  "title" => "",
+                  "body" => "",
+                  "body_format" => Appsignal::EventFormatter::DEFAULT,
+                  "count" => 1,
+                  "duration" => kind_of(Float)
+                )
+              ]
             )
           end
-
-          it "closes the transaction" do
-            expect(transaction).to receive(:complete)
-          end
-
-          after { job.perform }
         end
 
         context "with exception" do
           let(:job) { ::Resque::Job.new("default", "class" => "BrokenTestJob") }
-          let(:transaction) do
-            Appsignal::Transaction.new(
-              SecureRandom.uuid,
-              Appsignal::Transaction::BACKGROUND_JOB,
-              Appsignal::Transaction::GenericRequest.new({})
-            )
-          end
-          before do
-            allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-            expect(Appsignal::Transaction).to receive(:create)
-              .with(
-                kind_of(String),
-                Appsignal::Transaction::BACKGROUND_JOB,
-                kind_of(Appsignal::Transaction::GenericRequest)
-              ).and_return(transaction)
+
+          def perform
+            keep_transactions do
+              expect do
+                job.perform
+              end.to raise_error(ExampleException, "my error message")
+            end
           end
 
           it "sets the exception on the transaction" do
-            expect(transaction).to receive(:set_error).with(ExampleException)
-          end
+            expect do
+              perform
+            end.to change { created_transactions.length }.by(1)
 
-          after do
-            expect { job.perform }.to raise_error(ExampleException)
+            expect(last_transaction).to be_completed
+            expect(last_transaction.to_h).to include(
+              "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+              "action" => "BrokenTestJob#perform",
+              "error" => {
+                "name" => "ExampleException",
+                "message" => "my error message",
+                "backtrace" => kind_of(String)
+              }
+            )
           end
         end
       end