appsignal 2.9.18-java → 2.10.0-java

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

data/spec/lib/appsignal/minutely_spec.rb

@@ -189,7 +189,7 @@ describe Appsignal::Minutely do
       expect(Appsignal::Minutely).to have_received(:initial_wait_time).once
       expect do
         # Fetch old thread
-        thread = Appsignal::Minutely.class_variable_get(:@@thread)
+        thread = Appsignal::Minutely.instance_variable_get(:@thread)
         Appsignal::Minutely.start
         thread && thread.join # Wait for old thread to exit
       end.to_not(change { alive_thread_counter.call })
@@ -203,7 +203,7 @@ describe Appsignal::Minutely do
 
     it "stops the minutely thread" do
       Appsignal::Minutely.start
-      thread = Appsignal::Minutely.class_variable_get(:@@thread)
+      thread = Appsignal::Minutely.instance_variable_get(:@thread)
       expect(%w[sleep run]).to include(thread.status)
       Appsignal::Minutely.stop
       thread.join
@@ -213,7 +213,7 @@ describe Appsignal::Minutely do
     it "clears the probe instances array" do
       Appsignal::Minutely.probes.register :my_probe, lambda {}
       Appsignal::Minutely.start
-      thread = Appsignal::Minutely.class_variable_get(:@@thread)
+      thread = Appsignal::Minutely.instance_variable_get(:@thread)
       wait_for("probes initialized") do
         !Appsignal::Minutely.send(:probe_instances).empty?
       end

data/spec/lib/appsignal/rack/js_exception_catcher_spec.rb

@@ -3,19 +3,33 @@ describe Appsignal::Rack::JSExceptionCatcher do
   let(:options)        { nil }
   let(:config_options) { { :enable_frontend_error_catching => true } }
   let(:config)         { project_fixture_config("production", config_options) }
+  let(:deprecation_message) do
+    "The Appsignal::Rack::JSExceptionCatcher is deprecated. " \
+      "Please use the official AppSignal JavaScript integration instead. " \
+      "https://docs.appsignal.com/front-end/"
+  end
   before { Appsignal.config = config }
 
   describe "#initialize" do
     it "logs to the logger" do
-      expect(Appsignal.logger).to receive(:debug)
-        .with("Initializing Appsignal::Rack::JSExceptionCatcher")
-
-      Appsignal::Rack::JSExceptionCatcher.new(app, options)
+      stdout = std_stream
+      stderr = std_stream
+      log = capture_logs do
+        capture_std_streams(stdout, stderr) do
+          Appsignal::Rack::JSExceptionCatcher.new(app, options)
+        end
+      end
+      expect(log).to contains_log(:warn, deprecation_message)
+      expect(log).to contains_log(:debug, "Initializing Appsignal::Rack::JSExceptionCatcher")
+      expect(stdout.read).to include "appsignal WARNING: #{deprecation_message}"
+      expect(stderr.read).to_not include("appsignal:")
     end
   end
 
   describe "#call" do
-    let(:catcher) { Appsignal::Rack::JSExceptionCatcher.new(app, options) }
+    let(:catcher) do
+      silence { Appsignal::Rack::JSExceptionCatcher.new(app, options) }
+    end
     after { catcher.call(env) }
 
     context "when path is not frontend_error_catching_path" do

data/spec/lib/appsignal/transaction_spec.rb

@@ -64,7 +64,7 @@ describe Appsignal::Transaction do
 
         it "logs a debug message" do
           create_transaction("2")
-          expect(log_contents(log)).to contains_log :debug,
+          expect(log_contents(log)).to contains_log :warn,
             "Trying to start new transaction with id '2', but a " \
             "transaction with id '#{transaction_id}' is already " \
             "running. Using transaction '#{transaction_id}'."
@@ -154,13 +154,8 @@ describe Appsignal::Transaction do
   describe "#complete" do
     context "when transaction is being sampled" do
       it "samples data" do
-        expect(transaction.ext).to receive(:finish).and_return(true)
-        # Stub call to extension, because that would remove the transaction
-        # from the extension.
-        expect(transaction.ext).to receive(:complete)
-
         transaction.set_tags(:foo => "bar")
-        transaction.complete
+        keep_transactions { transaction.complete }
         expect(transaction.to_h["sample_data"]).to include(
           "tags" => { "foo" => "bar" }
         )
@@ -169,11 +164,8 @@ describe Appsignal::Transaction do
 
     context "when transaction is not being sampled" do
       it "does not sample data" do
-        expect(transaction).to_not receive(:sample_data)
-        expect(transaction.ext).to receive(:finish).and_return(false)
-        expect(transaction.ext).to receive(:complete).and_call_original
-
-        transaction.complete
+        keep_transactions(:sample => false) { transaction.complete }
+        expect(transaction.to_h["sample_data"]).to be_empty
       end
     end
 

data/spec/lib/appsignal_spec.rb

@@ -30,7 +30,7 @@ describe Appsignal do
     context "with no config set beforehand" do
       it "should do nothing when config is not set and there is no valid config in the env" do
         expect(Appsignal.logger).to receive(:error).with(
-          "Push api key not set after loading config"
+          "Push API key not set after loading config"
         ).once
         expect(Appsignal.logger).to receive(:error).with(
           "Not starting, no valid config for this environment"
@@ -701,13 +701,12 @@ describe Appsignal do
       context "when given a block" do
         it "yields the transaction and allows additional metadata to be set" do
           captured_transaction = nil
-          Appsignal.send_error(StandardError.new("my_error")) do |transaction|
-            captured_transaction = transaction
-            transaction.set_action("my_action")
-            transaction.set_namespace("my_namespace")
-
-            # Don't flush the transaction, so we can inspect it
-            expect(transaction).to receive(:complete)
+          keep_transactions do
+            Appsignal.send_error(StandardError.new("my_error")) do |transaction|
+              captured_transaction = transaction
+              transaction.set_action("my_action")
+              transaction.set_namespace("my_namespace")
+            end
           end
           expect(captured_transaction.to_h).to include(
             "namespace" => "my_namespace",

data/spec/spec_helper.rb

@@ -31,16 +31,9 @@ if DependencyHelper.rails_present?
   end
 end
 require "appsignal"
-
-module Appsignal
-  class << self
-    remove_method :testing?
-
-    def testing?
-      true
-    end
-  end
-end
+# Include patches of AppSignal modules and classes to make test helpers
+# available.
+require File.join(DirectoryHelper.support_dir, "testing.rb")
 
 puts "Running specs in #{RUBY_VERSION} on #{RUBY_PLATFORM}\n\n"
 
@@ -72,6 +65,12 @@ RSpec.configure do |config|
 
   config.example_status_persistence_file_path = "spec/examples.txt"
   config.fail_if_no_examples = true
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+  end
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
 
   def spec_system_tmp_dir
     File.join(tmp_dir, "system-tmp")
@@ -114,7 +113,8 @@ RSpec.configure do |config|
   end
 
   config.after do
-    Thread.current[:appsignal_transaction] = nil
+    Appsignal::Testing.clear!
+    clear_current_transaction!
     stop_minutely_probes
   end