appsignal 2.10.7-java → 2.11.0.alpha.2-java

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/sidekiq_spec.rb

@@ -48,147 +48,225 @@ 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
+  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")
+    end
 
-        transaction_hash = transaction.to_h
-        expect(transaction_hash["metadata"].keys)
-          .to_not include(*Appsignal::Hooks::SidekiqPlugin::JOB_KEYS)
-      end
+    it "stores no sample data" do
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "sample_data" => {
+          "environment" => {},
+          "params" => [],
+          "tags" => {}
+        }
+      )
     end
 
-    context "with parameter filtering" do
-      before do
-        Appsignal.config = project_fixture_config("production")
-        Appsignal.config[:filter_parameters] = ["foo"]
-      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}"
+      )
+    end
+  end
 
-      it "filters selected arguments" 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["sample_data"]).to include(
-          "params" => [
-            "foo",
-            {
-              "foo" => "[FILTERED]",
-              "bar" => "Bar",
-              "baz" => { "1" => "foo" }
-            }
-          ]
-        )
-      end
+      transaction_hash = transaction.to_h
+      expect(transaction_hash["metadata"].keys)
+        .to_not include(*Appsignal::Hooks::SidekiqPlugin::JOB_KEYS)
     end
+  end
 
-    context "with encrypted arguments" do
-      before do
-        item["encrypt"] = true
-        item["args"] << "super secret value" # Last argument will be replaced
-      end
+  context "with parameter filtering" do
+    before do
+      Appsignal.config = project_fixture_config("production")
+      Appsignal.config[:filter_parameters] = ["foo"]
+    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
+  context "with encrypted arguments" do
+    before do
+      item["encrypt"] = true
+      item["args"] << "super secret value" # Last argument will be replaced
+    end
 
-      it "uses the delayed class and method name for the action" do
+    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" => "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("DelayedTestClass.foo_method")
-        expect(transaction_hash["sample_data"]).to include(
-          "params" => ["bar" => "baz"]
-        )
+        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 job arguments is a malformed YAML object", :with_yaml_parse_error => true do
-        before { item["args"] = [] }
+  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 "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::DelayedClass#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 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
+    context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
+      before { item["args"] = [] }
 
-      it "uses the delayed class and method name for the action" do
+      it "logs a warning and uses the default argument" 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"]
-        )
+        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 "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
-        before { item["args"] = [] }
+  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
 
-        it "logs a warning and uses the default argument" do
-          perform_job
+    it "creates a transaction with events" 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).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 "when using ActiveJob" do
+    context "with ActionMailer job" do
       let(:item) do
         {
           "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-          "wrapped" => "ActiveJobTestClass",
+          "wrapped" => "ActionMailer::DeliveryJob",
           "queue" => "default",
           "args" => [{
-            "job_class" => "ActiveJobTestJob",
+            "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 } }
             ]
           }],
@@ -199,13 +277,13 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
         }
       end
 
-      it "creates a transaction with events" do
+      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" => "ActiveJobTestClass#perform",
+          "action" => "MailerClass#mailer_method",
           "error" => nil,
           "namespace" => namespace,
           "metadata" => {
@@ -224,43 +302,87 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
             "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
+      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" }
+            }
+          ]
         )
-        expect_transaction_to_have_sidekiq_event(transaction_hash)
       end
+    end
 
-      context "with ActionMailer job" do
-        let(:item) do
+    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
           {
-            "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
+            "job_class" => "ActiveMailerTestJob",
+            "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
+            "queue_name" => "default",
+            "arguments" => [
+              "foo", { "foo" => "Foo", "bar" => "Bar", "baz" => { 1 => :bar } }
+            ]
           }
         end
 
-        it "creates a transaction for the ActionMailer class" do
-          perform_job
+        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),
-            "action" => "MailerClass#mailer_method",
             "error" => nil,
             "namespace" => namespace,
             "metadata" => {
@@ -280,137 +402,13 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
             }
           )
         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" }
-              }
-            ]
+        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
-
-      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
-      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")
-    end
-
-    it "stores no sample data" do
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include(
-        "sample_data" => {
-          "environment" => {},
-          "params" => [],
-          "tags" => {}
-        }
-      )
-    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}"
-      )
     end
   end
 
@@ -452,8 +450,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 +483,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
@@ -537,7 +531,7 @@ describe Appsignal::Hooks::SidekiqHook do
   describe "#install" do
     before do
       Appsignal.config = project_fixture_config
-      class Sidekiq
+      module Sidekiq
         def self.middlewares
           @middlewares ||= Set.new
         end
@@ -560,203 +554,3 @@ describe Appsignal::Hooks::SidekiqHook do
     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
-
-          def retry_size
-            12
-          end
-
-          # 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
-        end
-
-        class Queue
-          Queue = Struct.new(:name, :size, :latency)
-
-          def self.all
-            [
-              Queue.new("default", 10, 12),
-              Queue.new("critical", 1, 2)
-            ]
-          end
-        end
-      end
-    end
-    after { Object.send(:remove_const, "Sidekiq") }
-
-    describe ".dependencies_present?" do
-      before do
-        class Redis; end
-        Redis.const_set(:VERSION, version)
-      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
-      end
-
-      context "when Redis version is >= 3.3.5" do
-        let(:version) { "3.3.5" }
-
-        it "does not start probe" do
-          expect(described_class.dependencies_present?).to be_truthy
-        end
-      end
-    end
-
-    it "loads Sidekiq::API" do
-      expect(defined?(Sidekiq::API)).to be_falsy
-      probe
-      expect(defined?(Sidekiq::API)).to be_truthy
-    end
-
-    it "logs config on initialize" do
-      log = capture_logs { probe }
-      expect(log).to contains_log(:debug, "Initializing Sidekiq probe\n")
-    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
-      before do
-        allow(Sidekiq).to receive(:respond_to?).with(:redis_info).and_return(false)
-      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
-      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)
-      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
-    end
-  end
-end