appsignal 2.10.8 → 2.11.0.beta.1

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

@@ -55,7 +55,7 @@ describe Appsignal::Hooks::PumaHook do
 
             Appsignal::Hooks::PumaHook.new.install
             probe = Appsignal::Minutely.probes[:puma]
-            expect(probe).to eql(Appsignal::Hooks::PumaProbe)
+            expect(probe).to eql(Appsignal::Probes::PumaProbe)
           end
         end
       end
@@ -101,7 +101,7 @@ describe Appsignal::Hooks::PumaHook do
 
             Appsignal::Hooks::PumaHook.new.install
             probe = Appsignal::Minutely.probes[:puma]
-            expect(probe).to eql(Appsignal::Hooks::PumaProbe)
+            expect(probe).to eql(Appsignal::Probes::PumaProbe)
           end
         end
       end
@@ -116,182 +116,3 @@ describe Appsignal::Hooks::PumaHook do
     end
   end
 end
-
-describe Appsignal::Hooks::PumaProbe do
-  before(:context) do
-    Appsignal.config = project_fixture_config
-  end
-  after(:context) do
-    Appsignal.config = nil
-  end
-
-  let(:probe) { Appsignal::Hooks::PumaProbe.new }
-
-  describe "hostname" do
-    it "returns the socket hostname" do
-      expect(probe.send(:hostname)).to eql(Socket.gethostname)
-    end
-
-    context "with overridden hostname" do
-      around do |sample|
-        Appsignal.config[:hostname] = "frontend1"
-        sample.run
-        Appsignal.config[:hostname] = nil
-      end
-      it "returns the configured host" do
-        expect(probe.send(:hostname)).to eql("frontend1")
-      end
-    end
-  end
-
-  describe "#call" do
-    let(:expected_default_tags) { { :hostname => Socket.gethostname } }
-
-    context "with multiple worker stats" do
-      before(:context) do
-        class Puma
-          def self.stats
-            {
-              "workers" => 2,
-              "booted_workers" => 2,
-              "old_workers" => 0,
-              "worker_status" => [
-                {
-                  "last_status" => {
-                    "backlog" => 0,
-                    "running" => 5,
-                    "pool_capacity" => 5,
-                    "max_threads" => 5
-                  }
-                },
-                {
-                  "last_status" => {
-                    "backlog" => 0,
-                    "running" => 5,
-                    "pool_capacity" => 5,
-                    "max_threads" => 5
-                  }
-                }
-              ]
-            }.to_json
-          end
-        end
-      end
-      after(:context) { Object.send(:remove_const, :Puma) }
-
-      it "calls `puma_gauge` with the (summed) worker metrics" do
-        expect_gauge(:workers, 2, :type => :count)
-        expect_gauge(:workers, 2, :type => :booted)
-        expect_gauge(:workers, 0, :type => :old)
-
-        expect_gauge(:connection_backlog, 0)
-        expect_gauge(:pool_capacity, 10)
-        expect_gauge(:threads, 10, :type => :running)
-        expect_gauge(:threads, 10, :type => :max)
-
-        probe.call
-      end
-    end
-
-    context "with single worker stats" do
-      before(:context) do
-        class Puma
-          def self.stats
-            {
-              "backlog" => 0,
-              "running" => 5,
-              "pool_capacity" => 5,
-              "max_threads" => 5
-            }.to_json
-          end
-        end
-      end
-      after(:context) { Object.send(:remove_const, :Puma) }
-
-      it "calls `puma_gauge` with the (summed) worker metrics" do
-        expect_gauge(:connection_backlog, 0)
-        expect_gauge(:pool_capacity, 5)
-        expect_gauge(:threads, 5, :type => :running)
-        expect_gauge(:threads, 5, :type => :max)
-        probe.call
-      end
-    end
-
-    context "without stats" do
-      before(:context) do
-        class Puma
-          def self.stats
-          end
-        end
-      end
-      after(:context) { Object.send(:remove_const, :Puma) }
-
-      context "when it returns nil" do
-        it "does not track metrics" do
-          expect(probe).to_not receive(:puma_gauge)
-          probe.call
-        end
-      end
-
-      # Puma.stats raises a NoMethodError on a nil object on the first call.
-      context "when it returns a NoMethodError on the first call" do
-        let(:log) { StringIO.new }
-
-        it "ignores the first call and tracks the second call" do
-          use_logger_with log do
-            expect(Puma).to receive(:stats)
-              .and_raise(NoMethodError.new("undefined method `stats' for nil:NilClass"))
-            probe.call
-
-            expect(Puma).to receive(:stats).and_return({
-              "backlog" => 1,
-              "running" => 5,
-              "pool_capacity" => 4,
-              "max_threads" => 6
-            }.to_json)
-
-            expect_gauge(:connection_backlog, 1)
-            expect_gauge(:pool_capacity, 4)
-            expect_gauge(:threads, 5, :type => :running)
-            expect_gauge(:threads, 6, :type => :max)
-            probe.call
-          end
-
-          expect(log_contents(log)).to_not contains_log(:error, "Error in minutely probe 'puma'")
-        end
-      end
-
-      context "when it does not have a complete stats payload" do
-        let(:log) { StringIO.new }
-
-        it "tracks whatever metrics we do have" do
-          use_logger_with log do
-            expect(Puma).to receive(:stats).and_return({
-              "backlog" => 1,
-              "running" => 5
-            }.to_json)
-
-            expect_gauge(:connection_backlog, 1)
-            expect_no_gauge(:pool_capacity)
-            expect_gauge(:threads, 5, :type => :running)
-            expect_no_gauge(:threads, :type => :max)
-            probe.call
-          end
-
-          expect(log_contents(log)).to_not contains_log(:error, "Error in minutely probe 'puma'")
-        end
-      end
-    end
-
-    def expect_gauge(key, value, tags = {})
-      expect(Appsignal).to receive(:set_gauge)
-        .with("puma_#{key}", value, expected_default_tags.merge(tags))
-        .and_call_original
-    end
-
-    def expect_no_gauge(key, tags = {})
-      expect(Appsignal).to_not receive(:set_gauge)
-        .with("puma_#{key}", anything, tags)
-    end
-  end
-end

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

@@ -0,0 +1,185 @@
+describe Appsignal::Hooks::ResqueHook do
+  describe "#dependency_present?" do
+    subject { described_class.new.dependencies_present? }
+
+    context "when Resque is loaded" do
+      before { stub_const "Resque", 1 }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "when Resque is not loaded" do
+      before { hide_const "Resque" }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  if DependencyHelper.resque_present?
+    describe "#install" do
+      def perform_job(klass, options = {})
+        payload = { "class" => klass.to_s }.merge(options)
+        job = ::Resque::Job.new(queue, payload)
+        keep_transactions { job.perform }
+      end
+
+      let(:queue) { "default" }
+      let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+      before do
+        start_agent
+
+        class ResqueTestJob
+          def self.perform(*_args)
+          end
+        end
+
+        class ResqueErrorTestJob
+          def self.perform
+            raise "resque job error"
+          end
+        end
+
+        expect(Appsignal).to receive(:stop) # Resque calls stop after every job
+      end
+      around do |example|
+        keep_transactions { example.run }
+      end
+      after do
+        Object.send(:remove_const, :ResqueTestJob)
+        Object.send(:remove_const, :ResqueErrorTestJob)
+      end
+
+      it "tracks a transaction on perform" do
+        perform_job(ResqueTestJob)
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "id" => kind_of(String),
+          "action" => "ResqueTestJob#perform",
+          "error" => nil,
+          "namespace" => namespace,
+          "metadata" => {},
+          "sample_data" => { "tags" => { "queue" => queue } }
+        )
+        expect(transaction_hash["events"].map { |e| e["name"] })
+          .to eql(["perform.resque"])
+      end
+
+      context "with error" do
+        it "tracks the error on the transaction" do
+          expect do
+            perform_job(ResqueErrorTestJob)
+          end.to raise_error(RuntimeError, "resque job error")
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "id" => kind_of(String),
+            "action" => "ResqueErrorTestJob#perform",
+            "error" => {
+              "name" => "RuntimeError",
+              "message" => "resque job error",
+              "backtrace" => kind_of(String)
+            },
+            "namespace" => namespace,
+            "metadata" => {},
+            "sample_data" => { "tags" => { "queue" => queue } }
+          )
+        end
+      end
+
+      context "with arguments" do
+        before do
+          Appsignal.config = project_fixture_config("production")
+          Appsignal.config[:filter_parameters] = ["foo"]
+        end
+
+        it "filters out configured arguments" do
+          perform_job(
+            ResqueTestJob,
+            "args" => [
+              "foo",
+              {
+                "foo" => "secret",
+                "bar" => "Bar",
+                "baz" => { "1" => "foo" }
+              }
+            ]
+          )
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "id" => kind_of(String),
+            "action" => "ResqueTestJob#perform",
+            "error" => nil,
+            "namespace" => namespace,
+            "metadata" => {},
+            "sample_data" => {
+              "tags" => { "queue" => queue },
+              "params" => [
+                "foo",
+                {
+                  "foo" => "[FILTERED]",
+                  "bar" => "Bar",
+                  "baz" => { "1" => "foo" }
+                }
+              ]
+            }
+          )
+        end
+      end
+
+      context "with active job" do
+        before do
+          module ActiveJobMock
+            module QueueAdapters
+              module ResqueAdapter
+                module JobWrapper
+                  class << self
+                    def perform(job_data)
+                      # Basic ActiveJob stub for this test.
+                      # I haven't found a way to run Resque in a testing mode.
+                      Appsignal.set_action(job_data["job_class"])
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          stub_const "ActiveJob", ActiveJobMock
+        end
+        after { Object.send(:remove_const, :ActiveJobMock) }
+
+        it "does not set arguments but lets the ActiveJob intergration handle it" do
+          perform_job(
+            ResqueTestJob,
+            "class" => "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper",
+            "args" => [
+              {
+                "job_class" => "ResqueTestJobByActiveJob#perform",
+                "arguments" => ["an argument", "second argument"]
+              }
+            ]
+          )
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "id" => kind_of(String),
+            "action" => "ResqueTestJobByActiveJob#perform",
+            "error" => nil,
+            "namespace" => namespace,
+            "metadata" => {},
+            "sample_data" => {
+              "tags" => { "queue" => queue }
+              # Params will be set by the ActiveJob integration
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,54 @@
+describe Appsignal::Hooks::SidekiqHook do
+  describe "#dependencies_present?" do
+    subject { described_class.new.dependencies_present? }
+
+    context "when Sidekiq constant is found" do
+      before { stub_const "Sidekiq", Class.new }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "when Sidekiq constant is not found" do
+      before { hide_const "Sidekiq" }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  describe "#install" do
+    class SidekiqMiddlewareMock < Set
+      def exists?(middleware)
+        include?(middleware)
+      end
+    end
+    module SidekiqMock
+      def self.middlewares
+        @middlewares ||= SidekiqMiddlewareMock.new
+      end
+
+      def self.configure_server
+        yield self
+      end
+
+      def self.server_middleware
+        yield middlewares if block_given?
+        middlewares
+      end
+    end
+
+    before do
+      Appsignal.config = project_fixture_config
+      stub_const "Sidekiq", SidekiqMock
+    end
+
+    it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
+      described_class.new.install
+
+      expect(Sidekiq.server_middleware.exists?(Appsignal::Hooks::SidekiqPlugin)).to be(true)
+    end
+  end
+end
+
 describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
   class DelayedTestClass; end
 
@@ -48,369 +99,132 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
     expect(log_contents(log)).to_not contains_log(:warn, "Unable to load YAML")
   end
 
-  shared_examples "sidekiq metadata" do
-    describe "internal Sidekiq job values" do
-      it "does not save internal Sidekiq values as metadata on transaction" do
-        perform_job
+  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::Hooks::SidekiqPlugin::JOB_KEYS)
-      end
+      transaction_hash = transaction.to_h
+      expect(transaction_hash["metadata"].keys)
+        .to_not include(*Appsignal::Hooks::SidekiqPlugin::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
+  context "with parameter filtering" do
+    before do
+      Appsignal.config = project_fixture_config("production")
+      Appsignal.config[:filter_parameters] = ["foo"]
     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
+    it "filters selected arguments" do
+      perform_job
 
-        transaction_hash = transaction.to_h
-        expect(transaction_hash["sample_data"]).to include(
-          "params" => expected_args << "[encrypted data]"
-        )
-      end
+      transaction_hash = transaction.to_h
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => [
+          "foo",
+          {
+            "foo" => "[FILTERED]",
+            "bar" => "Bar",
+            "baz" => { "1" => "foo" }
+          }
+        ]
+      )
     end
+  end
 
-    context "when using the Sidekiq delayed extension" do
-      let(:item) do
-        {
-          "jid" => "efb140489485999d32b5504c",
-          "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
+  context "with encrypted arguments" do
+    before do
+      item["encrypt"] = true
+      item["args"] << "super secret value" # Last argument will be replaced
     end
 
-    context "when using the Sidekiq ActiveRecord instance delayed extension" do
-      let(:item) do
-        {
-          "jid" => "efb140489485999d32b5504c",
-          "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
+    it "replaces the last argument (the secret bag) with an [encrypted data] string" 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
+      transaction_hash = transaction.to_h
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => expected_args << "[encrypted data]"
+      )
+    end
+  end
 
-      context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
-        before { item["args"] = [] }
+  context "when using the Sidekiq delayed extension" do
+    let(:item) do
+      {
+        "jid" => "efb140489485999d32b5504c",
+        "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 "logs a warning and uses the default argument" do
-          perform_job
+    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("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
+      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 using ActiveJob" do
-      let(:item) do
-        {
-          "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-          "wrapped" => "ActiveJobTestClass",
-          "queue" => "default",
-          "args" => [{
-            "job_class" => "ActiveJobTestJob",
-            "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
-            "queue_name" => "default",
-            "arguments" => [
-              "foo", { "foo" => "Foo", "bar" => "Bar", "baz" => { 1 => :bar } }
-            ]
-          }],
-          "retry" => true,
-          "jid" => "efb140489485999d32b5504c",
-          "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
-          "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f
-        }
-      end
+    context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
+      before { item["args"] = [] }
 
-      it "creates a transaction with events" do
+      it "logs a warning and uses the default argument" do
         perform_job
 
         transaction_hash = transaction.to_h
-        expect(transaction_hash).to include(
-          "id" => kind_of(String),
-          "action" => "ActiveJobTestClass#perform",
-          "error" => nil,
-          "namespace" => namespace,
-          "metadata" => {
-            "queue" => "default"
-          },
-          "sample_data" => {
-            "environment" => {},
-            "params" => [
-              "foo",
-              {
-                "foo" => "Foo",
-                "bar" => "Bar",
-                "baz" => { "1" => "bar" }
-              }
-            ],
-            "tags" => {}
-          }
-        )
-        # 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
-
-      context "with ActionMailer job" do
-        let(:item) do
-          {
-            "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-            "wrapped" => "ActionMailer::DeliveryJob",
-            "queue" => "default",
-            "args" => [{
-              "job_class" => "ActiveMailerTestJob",
-              "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
-              "queue_name" => "default",
-              "arguments" => [
-                "MailerClass", "mailer_method", "deliver_now",
-                "foo", { "foo" => "Foo", "bar" => "Bar", "baz" => { 1 => :bar } }
-              ]
-            }],
-            "retry" => true,
-            "jid" => "efb140489485999d32b5504c",
-            "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
-            "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f
-          }
-        end
-
-        it "creates a transaction for the ActionMailer class" do
-          perform_job
-
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include(
-            "id" => kind_of(String),
-            "action" => "MailerClass#mailer_method",
-            "error" => nil,
-            "namespace" => namespace,
-            "metadata" => {
-              "queue" => "default"
-            },
-            "sample_data" => {
-              "environment" => {},
-              "params" => [
-                "foo",
-                {
-                  "foo" => "Foo",
-                  "bar" => "Bar",
-                  "baz" => { "1" => "bar" }
-                }
-              ],
-              "tags" => {}
-            }
-          )
-        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" => "bar" }
-              }
-            ]
-          )
-        end
-      end
-
-      context "when Sidekiq job payload is missing the 'wrapped' value" do
-        let(:item) do
-          {
-            "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-            "queue" => "default",
-            "args" => [first_argument],
-            "retry" => true,
-            "jid" => "efb140489485999d32b5504c",
-            "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
-            "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f
-          }
-        end
-        before { perform_job }
-
-        context "when the first argument is not a Hash object" do
-          let(:first_argument) { "foo" }
-
-          include_examples "unknown job action name"
-        end
-
-        context "when the first argument is a Hash object not containing a job payload" do
-          let(:first_argument) { { "foo" => "bar" } }
-
-          include_examples "unknown job action name"
-
-          context "when the argument contains an invalid job_class value" do
-            let(:first_argument) { { "job_class" => :foo } }
-
-            include_examples "unknown job action name"
-          end
-        end
-
-        context "when the first argument is a Hash object containing a job payload" do
-          let(:first_argument) do
-            {
-              "job_class" => "ActiveMailerTestJob",
-              "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
-              "queue_name" => "default",
-              "arguments" => [
-                "foo", { "foo" => "Foo", "bar" => "Bar", "baz" => { 1 => :bar } }
-              ]
-            }
-          end
-
-          it "sets the action name to the job class in the first argument" do
-            transaction_hash = transaction.to_h
-            expect(transaction_hash).to include(
-              "action" => "ActiveMailerTestJob#perform"
-            )
-          end
-
-          it "stores the job metadata on the transaction" do
-            transaction_hash = transaction.to_h
-            expect(transaction_hash).to include(
-              "id" => kind_of(String),
-              "error" => nil,
-              "namespace" => namespace,
-              "metadata" => {
-                "queue" => "default"
-              },
-              "sample_data" => {
-                "environment" => {},
-                "params" => [
-                  "foo",
-                  {
-                    "foo" => "Foo",
-                    "bar" => "Bar",
-                    "baz" => { "1" => "bar" }
-                  }
-                ],
-                "tags" => {}
-              }
-            )
-          end
-
-          it "does not log a debug message" do
-            expect(log_contents(log)).to_not contains_log(
-              :debug, "Unable to determine an action name from Sidekiq payload"
-            )
-          end
-        end
+        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
 
-  shared_examples "unknown job action name" do
-    it "sets the action name to unknown" do
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include("action" => "unknown")
+  context "when using the Sidekiq ActiveRecord instance delayed extension" do
+    let(:item) do
+      {
+        "jid" => "efb140489485999d32b5504c",
+        "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 "stores no sample data" do
+    it "uses the delayed class and method name for the action" do
+      perform_job
+
       transaction_hash = transaction.to_h
-      expect(transaction_hash).to include(
-        "sample_data" => {
-          "environment" => {},
-          "params" => [],
-          "tags" => {}
-        }
+      expect(transaction_hash["action"]).to eq("DelayedTestClass#foo_method")
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => ["bar" => "baz"]
       )
     end
 
-    it "logs a debug message" do
-      expect(log_contents(log)).to contains_log(
-        :debug, "Unable to determine an action name from Sidekiq payload: #{item}"
-      )
+    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
 
@@ -452,8 +266,6 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
       )
       expect_transaction_to_have_sidekiq_event(transaction_hash)
     end
-
-    include_examples "sidekiq metadata"
   end
 
   context "without an error" do
@@ -487,8 +299,6 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
       )
       expect_transaction_to_have_sidekiq_event(transaction_hash)
     end
-
-    include_examples "sidekiq metadata"
   end
 
   def perform_job
@@ -516,247 +326,183 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
   end
 end
 
-describe Appsignal::Hooks::SidekiqHook do
-  describe "#dependencies_present?" do
-    subject { described_class.new.dependencies_present? }
-
-    context "when Sidekiq constant is found" do
-      before { Object.const_set("Sidekiq", 1) }
-      after { Object.send(:remove_const, "Sidekiq") }
-
-      it { is_expected.to be_truthy }
+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
-
-    context "when Sidekiq constant is not found" do
-      before { Object.send(:remove_const, "Sidekiq") if defined?(Sidekiq) }
-
-      it { is_expected.to be_falsy }
+    let(:expected_args) do
+      [
+        "foo",
+        {
+          "_aj_symbol_keys" => ["foo"],
+          "foo" => "Foo",
+          "bar" => "Bar",
+          "baz" => {
+            "_aj_symbol_keys" => [],
+            "1" => "foo"
+          }
+        }
+      ]
     end
-  end
-
-  describe "#install" do
-    before do
-      Appsignal.config = project_fixture_config
-      class Sidekiq
-        def self.middlewares
-          @middlewares ||= Set.new
-        end
-
-        def self.configure_server
-          yield self
-        end
-
-        def self.server_middleware
-          yield middlewares
+    let(:expected_tags) do
+      {}.tap do |hash|
+        if DependencyHelper.rails_version >= Gem::Version.new("5.0.0")
+          hash["provider_job_id"] = kind_of(String)
         end
       end
     end
-    after { Object.send(:remove_const, "Sidekiq") }
-
-    it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
-      described_class.new.install
-
-      expect(Sidekiq.middlewares).to include(Appsignal::Hooks::SidekiqPlugin)
-    end
-  end
-end
-
-describe Appsignal::Hooks::SidekiqProbe do
-  describe "#call" do
-    let(:probe) { described_class.new }
-    let(:redis_hostname) { "localhost" }
-    let(:expected_default_tags) { { :hostname => "localhost" } }
     before do
-      Appsignal.config = project_fixture_config
-      class Sidekiq
-        def self.redis_info
-          {
-            "connected_clients" => 2,
-            "used_memory" => 1024,
-            "used_memory_rss" => 512
-          }
-        end
-
-        def self.redis
-          yield Client.new
-        end
-
-        class Client
-          def connection
-            { :host => "localhost" }
-          end
-        end
-
-        class Stats
-          class << self
-            attr_reader :calls
-
-            def count_call
-              @calls ||= -1
-              @calls += 1
-            end
-          end
-
-          def workers_size
-            # First method called, so count it towards a call
-            self.class.count_call
-            24
-          end
-
-          def processes_size
-            25
-          end
-
-          # Return two different values for two separate calls.
-          # This allows us to test the delta of the value send as a gauge.
-          def processed
-            [10, 15][self.class.calls]
-          end
-
-          # Return two different values for two separate calls.
-          # This allows us to test the delta of the value send as a gauge.
-          def failed
-            [10, 13][self.class.calls]
-          end
+      start_agent
+      Appsignal.logger = test_logger(log)
+      ActiveJob::Base.queue_adapter = :sidekiq
 
-          def retry_size
-            12
-          end
+      class ActiveJobSidekiqTestJob < ActiveJob::Base
+        self.queue_adapter = :sidekiq
 
-          # Return two different values for two separate calls.
-          # This allows us to test the delta of the value send as a gauge.
-          def dead_size
-            [10, 12][self.class.calls]
-          end
-
-          def scheduled_size
-            14
-          end
-
-          def enqueued
-            15
-          end
+        def perform(*_args)
         end
+      end
 
-        class Queue
-          Queue = Struct.new(:name, :size, :latency)
+      class ActiveJobSidekiqErrorTestJob < ActiveJob::Base
+        self.queue_adapter = :sidekiq
 
-          def self.all
-            [
-              Queue.new("default", 10, 12),
-              Queue.new("critical", 1, 2)
-            ]
-          end
+        def perform(*_args)
+          raise "uh oh"
         end
       end
-    end
-    after { Object.send(:remove_const, "Sidekiq") }
-
-    describe ".dependencies_present?" do
-      before do
-        class Redis; end
-        Redis.const_set(:VERSION, version)
+      # 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::Hooks::SidekiqPlugin
       end
-      after { Object.send(:remove_const, "Redis") }
-
-      context "when Redis version is < 3.3.5" do
-        let(:version) { "3.3.4" }
-
-        it "does not start probe" do
-          expect(described_class.dependencies_present?).to be_falsy
+    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
 
-      context "when Redis version is >= 3.3.5" do
-        let(:version) { "3.3.5" }
+    it "reports the transaction from the ActiveJob integration" do
+      perform_job(ActiveJobSidekiqTestJob, given_args)
 
-        it "does not start probe" do
-          expect(described_class.dependencies_present?).to be_truthy
-        end
-      end
+      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
 
-    it "loads Sidekiq::API" do
-      expect(defined?(Sidekiq::API)).to be_falsy
-      probe
-      expect(defined?(Sidekiq::API)).to be_truthy
-    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")
 
-    it "logs config on initialize" do
-      log = capture_logs { probe }
-      expect(log).to contains_log(:debug, "Initializing Sidekiq probe\n")
+        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
 
-    it "logs used hostname on call once" do
-      log = capture_logs { probe.call }
-      expect(log).to contains_log(
-        :debug,
-        %(Sidekiq probe: Using Redis server hostname "localhost" as hostname)
-      )
-      log = capture_logs { probe.call }
-      # Match more logs with incompelete message
-      expect(log).to_not contains_log(:debug, %(Sidekiq probe: ))
-    end
-
-    it "collects custom metrics" do
-      expect_gauge("worker_count", 24).twice
-      expect_gauge("process_count", 25).twice
-      expect_gauge("connection_count", 2).twice
-      expect_gauge("memory_usage", 1024).twice
-      expect_gauge("memory_usage_rss", 512).twice
-      expect_gauge("job_count", 5, :status => :processed) # Gauge delta
-      expect_gauge("job_count", 3, :status => :failed) # Gauge delta
-      expect_gauge("job_count", 12, :status => :retry_queue).twice
-      expect_gauge("job_count", 2, :status => :died) # Gauge delta
-      expect_gauge("job_count", 14, :status => :scheduled).twice
-      expect_gauge("job_count", 15, :status => :enqueued).twice
-      expect_gauge("queue_length", 10, :queue => "default").twice
-      expect_gauge("queue_latency", 12_000, :queue => "default").twice
-      expect_gauge("queue_length", 1, :queue => "critical").twice
-      expect_gauge("queue_latency", 2_000, :queue => "critical").twice
-      # Call probe twice so we can calculate the delta for some gauge values
-      probe.call
-      probe.call
-    end
-
-    context "when `redis_info` is not defined" do
+    context "with ActionMailer" do
+      include ActionMailerHelpers
+
       before do
-        allow(Sidekiq).to receive(:respond_to?).with(:redis_info).and_return(false)
+        class ActionMailerSidekiqTestJob < ActionMailer::Base
+          def welcome(*args)
+          end
+        end
       end
 
-      it "does not collect redis metrics" do
-        expect_gauge("connection_count", 2).never
-        expect_gauge("memory_usage", 1024).never
-        expect_gauge("memory_usage_rss", 512).never
-        probe.call
+      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
 
-    context "when hostname is configured for probe" do
-      let(:redis_hostname) { "my_redis_server" }
-      let(:probe) { described_class.new(:hostname => redis_hostname) }
-
-      it "uses the redis hostname for the hostname tag" do
-        allow(Appsignal).to receive(:set_gauge).and_call_original
-        log = capture_logs { probe }
-        expect(log).to contains_log(
-          :debug,
-          %(Initializing Sidekiq probe with config: {:hostname=>"#{redis_hostname}"})
-        )
-        log = capture_logs { probe.call }
-        expect(log).to contains_log(
-          :debug,
-          "Sidekiq probe: Using hostname config option #{redis_hostname.inspect} as hostname"
-        )
-        expect(Appsignal).to have_received(:set_gauge)
-          .with(anything, anything, :hostname => redis_hostname).at_least(:once)
+    def perform_sidekiq
+      Timecop.freeze(time) do
+        yield
+        # Combined with Sidekiq::Testing.fake! and drain_all we get a
+        # enqueue_at in the job data.
+        Sidekiq::Worker.drain_all
       end
     end
 
-    def expect_gauge(key, value, tags = {})
-      expect(Appsignal).to receive(:set_gauge)
-        .with("sidekiq_#{key}", value, expected_default_tags.merge(tags))
-        .and_call_original
+    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