appsignal 2.11.8-java → 3.0.1-java

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

@@ -3,12 +3,22 @@ describe Appsignal::Hooks::UnicornHook do
     before :context do
       module Unicorn
         class HttpServer
-          def worker_loop(worker)
+          def worker_loop(_worker)
+            @worker_loop = true
+          end
+
+          def worker_loop?
+            @worker_loop == true
           end
         end
 
         class Worker
           def close
+            @close = true
+          end
+
+          def close?
+            @close == true
           end
         end
       end
@@ -27,18 +37,19 @@ describe Appsignal::Hooks::UnicornHook do
       worker = double
 
       expect(Appsignal).to receive(:forked)
-      expect(server).to receive(:worker_loop_without_appsignal).with(worker)
 
       server.worker_loop(worker)
+
+      expect(server.worker_loop?).to be true
     end
 
     it "adds behavior to Unicorn::Worker#close" do
       worker = Unicorn::Worker.new
 
       expect(Appsignal).to receive(:stop)
-      expect(worker).to receive(:close_without_appsignal)
 
       worker.close
+      expect(worker.close?).to be true
     end
   end
 

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

@@ -10,19 +10,8 @@ describe Appsignal::Hooks::WebmachineHook do
         it { is_expected.to be_truthy }
       end
 
-      it "should include the run alias methods" do
-        expect(fsm).to respond_to(:run_with_appsignal)
-        expect(fsm).to respond_to(:run_without_appsignal)
-      end
-
-      it "should include the handle_exceptions alias methods" do
-        expect(
-          fsm.respond_to?(:handle_exceptions_with_appsignal, true)
-        ).to be_truthy
-
-        expect(
-          fsm.respond_to?(:handle_exceptions_without_appsignal, true)
-        ).to be_truthy
+      it "adds behavior to Webmachine::Decision::FSM" do
+        expect(fsm.class.ancestors.first).to eq(Appsignal::Integrations::WebmachineIntegration)
       end
     end
   else

data/spec/lib/appsignal/hooks_spec.rb

@@ -92,32 +92,16 @@ describe Appsignal::Hooks do
       capture_std_streams(std_stream, err_stream, &block)
     end
 
-    describe "SidekiqProbe" do
+    describe "SidekiqPlugin" do
       it "logs a deprecation message and returns the new constant" do
-        constant = call_constant { Appsignal::Hooks::SidekiqProbe }
+        constant = call_constant { Appsignal::Hooks::SidekiqPlugin }
 
-        expect(constant).to eql(Appsignal::Probes::SidekiqProbe)
-        expect(constant.name).to eql("Appsignal::Probes::SidekiqProbe")
+        expect(constant).to eql(Appsignal::Integrations::SidekiqMiddleware)
+        expect(constant.name).to eql("Appsignal::Integrations::SidekiqMiddleware")
 
         deprecation_message =
-          "The constant Appsignal::Hooks::SidekiqProbe has been deprecated. " \
-          "Please update the constant name to Appsignal::Probes::SidekiqProbe " \
-          "in the following file to remove this message.\n#{__FILE__}:"
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-      end
-    end
-
-    describe "PumaProbe" do
-      it "logs a deprecation message and returns the new constant" do
-        constant = call_constant { Appsignal::Hooks::PumaProbe }
-
-        expect(constant).to eql(Appsignal::Probes::PumaProbe)
-        expect(constant.name).to eql("Appsignal::Probes::PumaProbe")
-
-        deprecation_message =
-          "The constant Appsignal::Hooks::PumaProbe has been deprecated. " \
-          "Please update the constant name to Appsignal::Probes::PumaProbe " \
+          "The constant Appsignal::Hooks::SidekiqPlugin has been deprecated. " \
+          "Please update the constant name to Appsignal::Integrations::SidekiqMiddleware " \
           "in the following file to remove this message.\n#{__FILE__}:"
         expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
         expect(log).to contains_log :warn, deprecation_message

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

@@ -1,9 +1,5 @@
 require "appsignal/integrations/object"
 
-def is_ruby_19
-  RUBY_VERSION < "2.0"
-end
-
 describe Object do
   describe "#instrument_method" do
     context "with instance method" do
@@ -30,12 +26,57 @@ describe Object do
         before do
           Appsignal.config = project_fixture_config
           expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
+          expect(Appsignal.active?).to be_truthy
         end
         after { Appsignal.config = nil }
 
+        context "with different kind of arguments" do
+          let(:klass) do
+            Class.new do
+              def positional_arguments(param1, param2)
+                [param1, param2]
+              end
+              appsignal_instrument_method :positional_arguments
+
+              def positional_arguments_splat(*params)
+                params
+              end
+              appsignal_instrument_method :positional_arguments_splat
+
+              def keyword_arguments(a: nil, b: nil)
+                [a, b]
+              end
+              appsignal_instrument_method :keyword_arguments
+
+              def keyword_arguments_splat(**kwargs)
+                kwargs
+              end
+              appsignal_instrument_method :keyword_arguments_splat
+
+              def splat(*args, **kwargs)
+                [args, kwargs]
+              end
+              appsignal_instrument_method :splat
+            end
+          end
+
+          it "instruments the method and calls it" do
+            expect(instance.positional_arguments("abc", "def")).to eq(["abc", "def"])
+            expect(instance.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
+            expect(instance.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
+            expect(instance.keyword_arguments_splat(:a => "a", :b => "b"))
+              .to eq(:a => "a", :b => "b")
+
+            expect(instance.splat).to eq([[], {}])
+            expect(instance.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
+            expect(instance.splat("abc", "def")).to eq([["abc", "def"], {}])
+            expect(instance.splat("abc", "def", :a => "a", :b => "b"))
+              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
+          end
+        end
+
         context "with anonymous class" do
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -56,7 +97,6 @@ describe Object do
           let(:klass) { NamedClass }
 
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -81,7 +121,6 @@ describe Object do
           let(:klass) { MyModule::NestedModule::NamedClass }
 
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "bar.NamedClass.NestedModule.MyModule.other", nil, nil,
@@ -101,7 +140,6 @@ describe Object do
           end
 
           it "instruments with custom name" do
-            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -162,6 +200,51 @@ describe Object do
         end
         after { Appsignal.config = nil }
 
+        context "with different kind of arguments" do
+          let(:klass) do
+            Class.new do
+              def self.positional_arguments(param1, param2)
+                [param1, param2]
+              end
+              appsignal_instrument_class_method :positional_arguments
+
+              def self.positional_arguments_splat(*params)
+                params
+              end
+              appsignal_instrument_class_method :positional_arguments_splat
+
+              def self.keyword_arguments(a: nil, b: nil)
+                [a, b]
+              end
+              appsignal_instrument_class_method :keyword_arguments
+
+              def self.keyword_arguments_splat(**kwargs)
+                kwargs
+              end
+              appsignal_instrument_class_method :keyword_arguments_splat
+
+              def self.splat(*args, **kwargs)
+                [args, kwargs]
+              end
+              appsignal_instrument_class_method :splat
+            end
+          end
+
+          it "instruments the method and calls it" do
+            expect(klass.positional_arguments("abc", "def")).to eq(["abc", "def"])
+            expect(klass.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
+            expect(klass.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
+            expect(klass.keyword_arguments_splat(:a => "a", :b => "b"))
+              .to eq(:a => "a", :b => "b")
+
+            expect(klass.splat).to eq([[], {}])
+            expect(klass.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
+            expect(klass.splat("abc", "def")).to eq([["abc", "def"], {}])
+            expect(klass.splat("abc", "def", :a => "a", :b => "b"))
+              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
+          end
+        end
+
         context "with anonymous class" do
           it "instruments the method and calls it" do
             expect(Appsignal.active?).to be_truthy

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

@@ -150,10 +150,9 @@ if DependencyHelper.padrino_present?
             let(:path) { "/static" }
             before do
               env["sinatra.static_file"] = true
-              expect_any_instance_of(app)
-                .to receive(:route_without_appsignal).and_return([200, {}, ["foo"]])
+              app.controllers { get(:static) { "Static!" } }
             end
-            after { expect(response).to match_response(200, "foo") }
+            after { expect(response).to match_response(200, "Static!") }
 
             it "does not instrument the request" do
               expect_no_transaction_to_be_created

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

@@ -79,51 +79,6 @@ if DependencyHelper.rails_present?
 
         after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
       end
-
-      describe "frontend_error_catching middleware" do
-        let(:config) do
-          Appsignal::Config.new(
-            project_fixture_path,
-            "test",
-            :name => "MyApp",
-            :enable_frontend_error_catching => enable_frontend_error_catching
-          )
-        end
-        before { allow(Appsignal::Config).to receive(:new).and_return(config) }
-        after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
-
-        context "when enabled" do
-          let(:enable_frontend_error_catching) { true }
-
-          it "adds the Rails and JSExceptionCatcher middleware" do
-            expect(app.middleware).to receive(:insert_after).with(
-              ActionDispatch::DebugExceptions,
-              Appsignal::Rack::RailsInstrumentation
-            )
-
-            expect(app.middleware).to receive(:insert_before).with(
-              Appsignal::Rack::RailsInstrumentation,
-              Appsignal::Rack::JSExceptionCatcher
-            )
-          end
-        end
-
-        context "when not enabled" do
-          let(:enable_frontend_error_catching) { false }
-
-          it "adds the Rails middleware, but not the JSExceptionCatcher middleware" do
-            expect(app.middleware).to receive(:insert_after).with(
-              ActionDispatch::DebugExceptions,
-              Appsignal::Rack::RailsInstrumentation
-            )
-
-            expect(app.middleware).to_not receive(:insert_before).with(
-              Appsignal::Rack::RailsInstrumentation,
-              Appsignal::Rack::JSExceptionCatcher
-            )
-          end
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,524 @@
+require "appsignal/integrations/sidekiq"
+
+describe Appsignal::Integrations::SidekiqErrorHandler do
+  let(:log) { StringIO.new }
+  before do
+    start_agent
+    Appsignal.logger = test_logger(log)
+  end
+  around { |example| keep_transactions { example.run } }
+
+  context "without a current transction" do
+    let(:exception) do
+      begin
+        raise ExampleStandardError, "uh oh"
+      rescue => error
+        error
+      end
+    end
+    let(:job_context) do
+      {
+        :context => "Sidekiq internal error!",
+        :jobstr => "{ bad json }"
+      }
+    end
+
+    it "tracks error on a new transaction" do
+      described_class.new.call(exception, job_context)
+
+      transaction_hash = last_transaction.to_h
+      expect(transaction_hash["error"]).to include(
+        "name" => "ExampleStandardError",
+        "message" => "uh oh",
+        "backtrace" => kind_of(String)
+      )
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => {
+          "jobstr" => "{ bad json }"
+        }
+      )
+      expect(transaction_hash["metadata"]).to include(
+        "sidekiq_error" => "Sidekiq internal error!"
+      )
+    end
+  end
+end
+
+describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => false do
+  class DelayedTestClass; end
+
+  let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+  let(:worker) { anything }
+  let(:queue) { anything }
+  let(:given_args) do
+    [
+      "foo",
+      {
+        :foo => "Foo",
+        :bar => "Bar",
+        "baz" => { 1 => :foo }
+      }
+    ]
+  end
+  let(:expected_args) do
+    [
+      "foo",
+      {
+        "foo" => "Foo",
+        "bar" => "Bar",
+        "baz" => { "1" => "foo" }
+      }
+    ]
+  end
+  let(:job_class) { "TestClass" }
+  let(:jid) { "b4a577edbccf1d805744efa9" }
+  let(:item) do
+    {
+      "jid"         => jid,
+      "class"       => job_class,
+      "retry_count" => 0,
+      "queue"       => "default",
+      "created_at"  => Time.parse("2001-01-01 10:00:00UTC").to_f,
+      "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
+      "args"        => given_args,
+      "extra"       => "data"
+    }
+  end
+  let(:plugin) { Appsignal::Integrations::SidekiqMiddleware.new }
+  let(:log) { StringIO.new }
+  before do
+    start_agent
+    Appsignal.logger = test_logger(log)
+  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
+
+  describe "internal Sidekiq job values" do
+    it "does not save internal Sidekiq values as metadata on transaction" do
+      perform_job
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash["metadata"].keys)
+        .to_not include(*Appsignal::Integrations::SidekiqMiddleware::EXCLUDED_JOB_KEYS)
+    end
+  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_job
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => [
+          "foo",
+          {
+            "foo" => "[FILTERED]",
+            "bar" => "Bar",
+            "baz" => { "1" => "foo" }
+          }
+        ]
+      )
+    end
+  end
+
+  context "with encrypted arguments" do
+    before do
+      item["encrypt"] = true
+      item["args"] << "super secret value" # Last argument will be replaced
+    end
+
+    it "replaces the last argument (the secret bag) with an [encrypted data] string" do
+      perform_job
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => expected_args << "[encrypted data]"
+      )
+    end
+  end
+
+  context "when using the Sidekiq delayed extension" do
+    let(:item) do
+      {
+        "jid" => jid,
+        "class" => "Sidekiq::Extensions::DelayedClass",
+        "queue" => "default",
+        "args" => [
+          "---\n- !ruby/class 'DelayedTestClass'\n- :foo_method\n- - :bar: baz\n"
+        ],
+        "retry" => true,
+        "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
+        "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
+        "extra" => "data"
+      }
+    end
+
+    it "uses the delayed class and method name for the action" do
+      perform_job
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash["action"]).to eq("DelayedTestClass.foo_method")
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => ["bar" => "baz"]
+      )
+    end
+
+    context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
+      before { item["args"] = [] }
+
+      it "logs a warning and uses the default argument" do
+        perform_job
+
+        transaction_hash = transaction.to_h
+        expect(transaction_hash["action"]).to eq("Sidekiq::Extensions::DelayedClass#perform")
+        expect(transaction_hash["sample_data"]).to include("params" => [])
+        expect(log_contents(log)).to contains_log(:warn, "Unable to load YAML")
+      end
+    end
+  end
+
+  context "when using the Sidekiq ActiveRecord instance delayed extension" do
+    let(:item) do
+      {
+        "jid" => jid,
+        "class" => "Sidekiq::Extensions::DelayedModel",
+        "queue" => "default",
+        "args" => [
+          "---\n- !ruby/object:DelayedTestClass {}\n- :foo_method\n- - :bar: :baz\n"
+        ],
+        "retry" => true,
+        "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
+        "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
+        "extra" => "data"
+      }
+    end
+
+    it "uses the delayed class and method name for the action" do
+      perform_job
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash["action"]).to eq("DelayedTestClass#foo_method")
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => ["bar" => "baz"]
+      )
+    end
+
+    context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
+      before { item["args"] = [] }
+
+      it "logs a warning and uses the default argument" do
+        perform_job
+
+        transaction_hash = transaction.to_h
+        expect(transaction_hash["action"]).to eq("Sidekiq::Extensions::DelayedModel#perform")
+        expect(transaction_hash["sample_data"]).to include("params" => [])
+        expect(log_contents(log)).to contains_log(:warn, "Unable to load YAML")
+      end
+    end
+  end
+
+  context "with an error" do
+    let(:error) { ExampleException }
+
+    it "creates a transaction and adds the error" do
+      expect(Appsignal).to receive(:increment_counter)
+        .with("sidekiq_queue_job_count", 1, :queue => "default", :status => :failed)
+      expect(Appsignal).to receive(:increment_counter)
+        .with("sidekiq_queue_job_count", 1, :queue => "default", :status => :processed)
+
+      expect do
+        perform_job { raise error, "uh oh" }
+      end.to raise_error(error)
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "id" => jid,
+        "action" => "TestClass#perform",
+        "error" => {
+          "name" => "ExampleException",
+          "message" => "uh oh",
+          # TODO: backtrace should be an Array of Strings
+          # https://github.com/appsignal/appsignal-agent/issues/294
+          "backtrace" => kind_of(String)
+        },
+        "metadata" => {
+          "extra" => "data",
+          "queue" => "default",
+          "retry_count" => "0"
+        },
+        "namespace" => namespace,
+        "sample_data" => {
+          "environment" => {},
+          "params" => expected_args,
+          "tags" => {},
+          "breadcrumbs" => []
+        }
+      )
+      expect_transaction_to_have_sidekiq_event(transaction_hash)
+    end
+  end
+
+  context "without an error" do
+    it "creates a transaction with events" do
+      expect(Appsignal).to receive(:increment_counter)
+        .with("sidekiq_queue_job_count", 1, :queue => "default", :status => :processed)
+
+      perform_job
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "id" => jid,
+        "action" => "TestClass#perform",
+        "error" => nil,
+        "metadata" => {
+          "extra" => "data",
+          "queue" => "default",
+          "retry_count" => "0"
+        },
+        "namespace" => namespace,
+        "sample_data" => {
+          "environment" => {},
+          "params" => expected_args,
+          "tags" => {},
+          "breadcrumbs" => []
+        }
+      )
+      # TODO: Not available in transaction.to_h yet.
+      # https://github.com/appsignal/appsignal-agent/issues/293
+      expect(transaction.request.env).to eq(
+        :queue_start => Time.parse("2001-01-01 10:00:00UTC").to_f
+      )
+      expect_transaction_to_have_sidekiq_event(transaction_hash)
+    end
+  end
+
+  def perform_job
+    Timecop.freeze(Time.parse("2001-01-01 10:01:00UTC")) do
+      begin
+        exception = nil
+        plugin.call(worker, item, queue) do
+          yield if block_given?
+        end
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        raise exception
+      ensure
+        if exception
+          Appsignal::Integrations::SidekiqErrorHandler.new.call(exception, :job => item)
+        end
+      end
+    end
+  end
+
+  def transaction
+    last_transaction
+  end
+
+  def expect_transaction_to_have_sidekiq_event(transaction_hash)
+    events = transaction_hash["events"]
+    expect(events.count).to eq(1)
+    expect(events.first).to include(
+      "name"        => "perform_job.sidekiq",
+      "title"       => "",
+      "count"       => 1,
+      "body"        => "",
+      "body_format" => Appsignal::EventFormatter::DEFAULT
+    )
+  end
+end
+
+if DependencyHelper.active_job_present?
+  require "active_job"
+  require "action_mailer"
+  require "sidekiq/testing"
+
+  describe "Sidekiq ActiveJob integration" do
+    let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+    let(:time) { Time.parse("2001-01-01 10:00:00UTC") }
+    let(:log) { StringIO.new }
+    let(:given_args) do
+      [
+        "foo",
+        {
+          :foo => "Foo",
+          "bar" => "Bar",
+          "baz" => { "1" => "foo" }
+        }
+      ]
+    end
+    let(:expected_args) do
+      [
+        "foo",
+        {
+          "_aj_symbol_keys" => ["foo"],
+          "foo" => "Foo",
+          "bar" => "Bar",
+          "baz" => {
+            "_aj_symbol_keys" => [],
+            "1" => "foo"
+          }
+        }
+      ]
+    end
+    let(:expected_tags) do
+      {}.tap do |hash|
+        hash["active_job_id"] = kind_of(String)
+        if DependencyHelper.rails_version >= Gem::Version.new("5.0.0")
+          hash["provider_job_id"] = kind_of(String)
+        end
+      end
+    end
+    before do
+      start_agent
+      Appsignal.logger = test_logger(log)
+      ActiveJob::Base.queue_adapter = :sidekiq
+
+      class ActiveJobSidekiqTestJob < ActiveJob::Base
+        self.queue_adapter = :sidekiq
+
+        def perform(*_args)
+        end
+      end
+
+      class ActiveJobSidekiqErrorTestJob < ActiveJob::Base
+        self.queue_adapter = :sidekiq
+
+        def perform(*_args)
+          raise "uh oh"
+        end
+      end
+      # Manually add the AppSignal middleware for the Testing environment.
+      # It doesn't use configured middlewares by default looks like.
+      # We test somewhere else if the middleware is installed properly.
+      Sidekiq::Testing.server_middleware do |chain|
+        chain.add Appsignal::Integrations::SidekiqMiddleware
+      end
+    end
+    around do |example|
+      keep_transactions do
+        Sidekiq::Testing.fake! do
+          example.run
+        end
+      end
+    end
+    after do
+      Object.send(:remove_const, :ActiveJobSidekiqTestJob)
+      Object.send(:remove_const, :ActiveJobSidekiqErrorTestJob)
+    end
+
+    it "reports the transaction from the ActiveJob integration" do
+      perform_job(ActiveJobSidekiqTestJob, given_args)
+
+      transaction = last_transaction
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "ActiveJobSidekiqTestJob#perform",
+        "error" => nil,
+        "namespace" => namespace,
+        "metadata" => hash_including(
+          "queue" => "default"
+        ),
+        "sample_data" => hash_including(
+          "environment" => {},
+          "params" => [expected_args],
+          "tags" => expected_tags.merge("queue" => "default")
+        )
+      )
+      expect(transaction.request.env).to eq(:queue_start => time.to_f)
+      events = transaction_hash["events"]
+        .sort_by { |e| e["start"] }
+        .map { |event| event["name"] }
+      expect(events)
+        .to eq(["perform_job.sidekiq", "perform_start.active_job", "perform.active_job"])
+    end
+
+    context "with error" do
+      it "reports the error on the transaction from the ActiveRecord integration" do
+        expect do
+          perform_job(ActiveJobSidekiqErrorTestJob, given_args)
+        end.to raise_error(RuntimeError, "uh oh")
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "action" => "ActiveJobSidekiqErrorTestJob#perform",
+          "error" => {
+            "name" => "RuntimeError",
+            "message" => "uh oh",
+            "backtrace" => kind_of(String)
+          },
+          "namespace" => namespace,
+          "metadata" => hash_including(
+            "queue" => "default"
+          ),
+          "sample_data" => hash_including(
+            "environment" => {},
+            "params" => [expected_args],
+            "tags" => expected_tags.merge("queue" => "default")
+          )
+        )
+        expect(transaction.request.env).to eq(:queue_start => time.to_f)
+        events = transaction_hash["events"]
+          .sort_by { |e| e["start"] }
+          .map { |event| event["name"] }
+        expect(events)
+          .to eq(["perform_job.sidekiq", "perform_start.active_job", "perform.active_job"])
+      end
+    end
+
+    context "with ActionMailer" do
+      include ActionMailerHelpers
+
+      before do
+        class ActionMailerSidekiqTestJob < ActionMailer::Base
+          def welcome(*args)
+          end
+        end
+      end
+
+      it "reports ActionMailer data on the transaction" do
+        perform_mailer(ActionMailerSidekiqTestJob, :welcome, given_args)
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "action" => "ActionMailerSidekiqTestJob#welcome",
+          "sample_data" => hash_including(
+            "params" => ["ActionMailerSidekiqTestJob", "welcome", "deliver_now"] + expected_args
+          )
+        )
+      end
+    end
+
+    def perform_sidekiq
+      Timecop.freeze(time) do
+        begin
+          yield
+          # Combined with Sidekiq::Testing.fake! and drain_all we get a
+          # enqueue_at in the job data.
+          Sidekiq::Worker.drain_all
+        rescue Exception => exception # rubocop:disable Lint/RescueException
+          raise exception
+        ensure
+          if exception
+            Appsignal::Integrations::SidekiqErrorHandler.new.call(exception, {})
+          end
+        end
+      end
+    end
+
+    def perform_job(job_class, args)
+      perform_sidekiq { job_class.perform_later(args) }
+    end
+
+    def perform_mailer(mailer, method, args = nil)
+      perform_sidekiq { perform_action_mailer(mailer, method, args) }
+    end
+  end
+end