appsignal 3.0.0.beta.1 → 3.0.0.rc.1

data/lib/appsignal/integrations/object.rb

@@ -5,56 +5,34 @@ if defined?(Appsignal)
 end
 
 class Object
-  if Appsignal::System.ruby_2_7_or_newer?
-    def self.appsignal_instrument_class_method(method_name, options = {})
-      singleton_class.send \
-        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-      singleton_class.send(:define_method, method_name) do |*args, **kwargs, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
-        end
+  def self.appsignal_instrument_class_method(method_name, options = {})
+    singleton_class.send \
+      :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
+    singleton_class.send(:define_method, method_name) do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
       end
-    end
-
-    def self.appsignal_instrument_method(method_name, options = {})
-      alias_method "appsignal_uninstrumented_#{method_name}", method_name
-      define_method method_name do |*args, **kwargs, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, **kwargs, &block
-        end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
       end
     end
-  else
-    def self.appsignal_instrument_class_method(method_name, options = {})
-      singleton_class.send \
-        :alias_method, "appsignal_uninstrumented_#{method_name}", method_name
-      singleton_class.send(:define_method, method_name) do |*args, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.class_method.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, &block
-        end
-      end
+
+    if singleton_class.respond_to?(:ruby2_keywords, true) # rubocop:disable Style/GuardClause
+      singleton_class.send(:ruby2_keywords, method_name)
     end
+  end
 
-    def self.appsignal_instrument_method(method_name, options = {})
-      alias_method "appsignal_uninstrumented_#{method_name}", method_name
-      define_method method_name do |*args, &block|
-        name = options.fetch(:name) do
-          "#{method_name}.#{appsignal_reverse_class_name}.other"
-        end
-        Appsignal.instrument name do
-          send "appsignal_uninstrumented_#{method_name}", *args, &block
-        end
+  def self.appsignal_instrument_method(method_name, options = {})
+    alias_method "appsignal_uninstrumented_#{method_name}", method_name
+    define_method method_name do |*args, &block|
+      name = options.fetch(:name) do
+        "#{method_name}.#{appsignal_reverse_class_name}.other"
+      end
+      Appsignal.instrument name do
+        send "appsignal_uninstrumented_#{method_name}", *args, &block
       end
     end
+    ruby2_keywords method_name if respond_to?(:ruby2_keywords, true)
   end
 
   def self.appsignal_reverse_class_name

data/lib/appsignal/integrations/sidekiq.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Appsignal
+  module Integrations
+    # Error handler for Sidekiq to report errors from jobs and internal Sidekiq
+    # errors.
+    #
+    # @api private
+    class SidekiqErrorHandler
+      def call(exception, sidekiq_context)
+        transaction = Appsignal::Transaction.current
+
+        if transaction.nil_transaction?
+          # Sidekiq error outside of the middleware scope.
+          # Can be a job JSON parse error or some other error happening in
+          # Sidekiq.
+          transaction = Appsignal::Transaction.create(
+            SecureRandom.uuid, # Newly generated job id
+            Appsignal::Transaction::BACKGROUND_JOB,
+            Appsignal::Transaction::GenericRequest.new({})
+          )
+          transaction.set_action_if_nil("SidekiqInternal")
+          transaction.set_metadata("sidekiq_error", sidekiq_context[:context])
+          transaction.params = { :jobstr => sidekiq_context[:jobstr] }
+        end
+
+        transaction.set_error(exception)
+        Appsignal::Transaction.complete_current!
+      end
+    end
+
+    # @api private
+    class SidekiqMiddleware # rubocop:disable Metrics/ClassLength
+      include Appsignal::Hooks::Helpers
+
+      EXCLUDED_JOB_KEYS = %w[
+        args backtrace class created_at enqueued_at error_backtrace error_class
+        error_message failed_at jid retried_at retry wrapped
+      ].freeze
+
+      def call(_worker, item, _queue)
+        job_status = nil
+        transaction = Appsignal::Transaction.create(
+          item["jid"],
+          Appsignal::Transaction::BACKGROUND_JOB,
+          Appsignal::Transaction::GenericRequest.new(
+            :queue_start => item["enqueued_at"]
+          )
+        )
+
+        Appsignal.instrument "perform_job.sidekiq" do
+          yield
+        end
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        job_status = :failed
+        raise exception
+      ensure
+        if transaction
+          transaction.set_action_if_nil(formatted_action_name(item))
+
+          params = filtered_arguments(item)
+          transaction.params = params if params
+
+          formatted_metadata(item).each do |key, value|
+            transaction.set_metadata key, value
+          end
+          transaction.set_http_or_background_queue_start
+          Appsignal::Transaction.complete_current! unless exception
+
+          queue = item["queue"] || "unknown"
+          if job_status
+            increment_counter "queue_job_count", 1,
+              :queue => queue,
+              :status => job_status
+          end
+          increment_counter "queue_job_count", 1,
+            :queue => queue,
+            :status => :processed
+        end
+      end
+
+      private
+
+      def increment_counter(key, value, tags = {})
+        Appsignal.increment_counter "sidekiq_#{key}", value, tags
+      end
+
+      def formatted_action_name(job)
+        sidekiq_action_name = parse_action_name(job)
+        return unless sidekiq_action_name
+
+        complete_action = sidekiq_action_name =~ /\.|#/
+        return sidekiq_action_name if complete_action
+
+        "#{sidekiq_action_name}#perform"
+      end
+
+      def filtered_arguments(job)
+        arguments = parse_arguments(job)
+        return unless arguments
+
+        Appsignal::Utils::HashSanitizer.sanitize(
+          arguments,
+          Appsignal.config[:filter_parameters]
+        )
+      end
+
+      def formatted_metadata(item)
+        {}.tap do |hash|
+          (item || {}).each do |key, value|
+            next if EXCLUDED_JOB_KEYS.include?(key)
+
+            hash[key] = truncate(string_or_inspect(value))
+          end
+        end
+      end
+
+      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L316-L334
+      def parse_action_name(job)
+        args = job.fetch("args", [])
+        job_class = job["class"]
+        case job_class
+        when "Sidekiq::Extensions::DelayedModel"
+          safe_load(args[0], job_class) do |target, method, _|
+            "#{target.class}##{method}"
+          end
+        when /\ASidekiq::Extensions::Delayed/
+          safe_load(args[0], job_class) do |target, method, _|
+            "#{target}.#{method}"
+          end
+        else
+          job_class
+        end
+      end
+
+      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L336-L358
+      def parse_arguments(job)
+        args = job.fetch("args", [])
+        case job["class"]
+        when /\ASidekiq::Extensions::Delayed/
+          safe_load(args[0], args) do |_, _, arg|
+            arg
+          end
+        when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+          nil # Set in the ActiveJob integration
+        else
+          # Sidekiq Enterprise argument encryption.
+          # More information: https://github.com/mperham/sidekiq/wiki/Ent-Encryption
+          if job["encrypt".freeze]
+            # No point in showing 150+ bytes of random garbage
+            args[-1] = "[encrypted data]".freeze
+          end
+          args
+        end
+      end
+
+      # Based on: https://github.com/mperham/sidekiq/blob/63ee43353bd3b753beb0233f64865e658abeb1c3/lib/sidekiq/api.rb#L403-L412
+      def safe_load(content, default)
+        yield(*YAML.load(content))
+      rescue => error
+        # Sidekiq issue #1761: in dev mode, it's possible to have jobs enqueued
+        # which haven't been loaded into memory yet so the YAML can't be
+        # loaded.
+        Appsignal.logger.warn "Unable to load YAML: #{error.message}"
+        default
+      end
+    end
+  end
+end

data/lib/appsignal/minutely.rb

@@ -123,6 +123,12 @@ module Appsignal
       def start
         stop
         @thread = Thread.new do
+          # Advise multi-threaded app servers to ignore this thread
+          # for the purposes of fork safety warnings
+          if Thread.current.respond_to?(:thread_variable_set)
+            Thread.current.thread_variable_set(:fork_safe, true)
+          end
+
           sleep initial_wait_time
           initialize_probes
           loop do

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.0.0.beta.1".freeze
+  VERSION = "3.0.0.rc.1".freeze
 end

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

@@ -2,6 +2,8 @@ describe Appsignal::Hooks::ActionCableHook do
   if DependencyHelper.action_cable_present?
     context "with ActionCable" do
       require "action_cable/engine"
+      # Require test helper to test with ConnectionStub
+      require "action_cable/channel/test_case" if DependencyHelper.rails6_present?
 
       describe ".dependencies_present?" do
         subject { described_class.new.dependencies_present? }
@@ -262,6 +264,49 @@ describe Appsignal::Hooks::ActionCableHook do
               )
             end
           end
+
+          if DependencyHelper.rails6_present?
+            context "with ConnectionStub" do
+              let(:connection) { ActionCable::Channel::ConnectionStub.new }
+              let(:transaction_id) { "Stubbed transaction id" }
+              before do
+                # Stub future (private AppSignal) transaction id generated by the hook.
+                expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              end
+
+              it "does not fail on missing `#env` method on `ConnectionStub`" do
+                instance.subscribe_to_channel
+
+                expect(subject).to include(
+                  "action" => "MyChannel#subscribed",
+                  "error" => nil,
+                  "id" => transaction_id,
+                  "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                  "metadata" => {
+                    "method" => "websocket",
+                    "path" => "" # No path as the ConnectionStub doesn't have the real request env
+                  }
+                )
+                expect(subject["events"].first).to include(
+                  "allocation_count" => kind_of(Integer),
+                  "body" => "",
+                  "body_format" => Appsignal::EventFormatter::DEFAULT,
+                  "child_allocation_count" => kind_of(Integer),
+                  "child_duration" => kind_of(Float),
+                  "child_gc_duration" => kind_of(Float),
+                  "count" => 1,
+                  "gc_duration" => kind_of(Float),
+                  "start" => kind_of(Float),
+                  "duration" => kind_of(Float),
+                  "name" => "subscribed.action_cable",
+                  "title" => ""
+                )
+                expect(subject["sample_data"]).to include(
+                  "params" => { "internal" => "true" }
+                )
+              end
+            end
+          end
         end
 
         describe "unsubscribe callback" do
@@ -349,6 +394,49 @@ describe Appsignal::Hooks::ActionCableHook do
               )
             end
           end
+
+          if DependencyHelper.rails6_present?
+            context "with ConnectionStub" do
+              let(:connection) { ActionCable::Channel::ConnectionStub.new }
+              let(:transaction_id) { "Stubbed transaction id" }
+              before do
+                # Stub future (private AppSignal) transaction id generated by the hook.
+                expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
+              end
+
+              it "does not fail on missing `#env` method on `ConnectionStub`" do
+                instance.unsubscribe_from_channel
+
+                expect(subject).to include(
+                  "action" => "MyChannel#unsubscribed",
+                  "error" => nil,
+                  "id" => transaction_id,
+                  "namespace" => Appsignal::Transaction::ACTION_CABLE,
+                  "metadata" => {
+                    "method" => "websocket",
+                    "path" => "" # No path as the ConnectionStub doesn't have the real request env
+                  }
+                )
+                expect(subject["events"].first).to include(
+                  "allocation_count" => kind_of(Integer),
+                  "body" => "",
+                  "body_format" => Appsignal::EventFormatter::DEFAULT,
+                  "child_allocation_count" => kind_of(Integer),
+                  "child_duration" => kind_of(Float),
+                  "child_gc_duration" => kind_of(Float),
+                  "count" => 1,
+                  "gc_duration" => kind_of(Float),
+                  "start" => kind_of(Float),
+                  "duration" => kind_of(Float),
+                  "name" => "unsubscribed.action_cable",
+                  "title" => ""
+                )
+                expect(subject["sample_data"]).to include(
+                  "params" => { "internal" => "true" }
+                )
+              end
+            end
+          end
         end
       end
     end

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

@@ -16,14 +16,31 @@ describe Appsignal::Hooks::SidekiqHook do
   end
 
   describe "#install" do
-    class SidekiqMiddlewareMock < Set
-      def exists?(middleware)
-        include?(middleware)
+    class SidekiqMiddlewareMockWithPrepend < Array
+      alias add <<
+      alias exists? include?
+
+      unless method_defined? :prepend
+        def prepend(middleware) # For Ruby < 2.5
+          insert(0, middleware)
+        end
       end
     end
+
+    class SidekiqMiddlewareMockWithoutPrepend < Array
+      alias add <<
+      alias exists? include?
+
+      undef_method :prepend if method_defined? :prepend # For Ruby >= 2.5
+    end
+
     module SidekiqMock
+      def self.middleware_mock=(mock)
+        @middlewares = mock.new
+      end
+
       def self.middlewares
-        @middlewares ||= SidekiqMiddlewareMock.new
+        @middlewares
       end
 
       def self.configure_server
@@ -34,479 +51,64 @@ describe Appsignal::Hooks::SidekiqHook do
         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
-
-  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::Hooks::SidekiqPlugin.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::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
-  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")
+      def self.error_handlers
+        @error_handlers ||= []
       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")
+    def add_middleware(middleware)
+      Sidekiq.configure_server do |sidekiq_config|
+        sidekiq_config.middlewares.add(middleware)
       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
-      plugin.call(worker, item, queue) do
-        yield if block_given?
-      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::Hooks::SidekiqPlugin
-      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"])
+      Appsignal.config = project_fixture_config
+      stub_const "Sidekiq", SidekiqMock
     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
+    it "adds error handler" do
+      Sidekiq.middleware_mock = SidekiqMiddlewareMockWithPrepend
+      described_class.new.install
+      expect(Sidekiq.error_handlers).to include(Appsignal::Integrations::SidekiqErrorHandler)
     end
 
-    context "with ActionMailer" do
-      include ActionMailerHelpers
+    context "when Sidekiq middleware responds to prepend method" do # Sidekiq 3.3.0 and newer
+      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithPrepend }
 
-      before do
-        class ActionMailerSidekiqTestJob < ActionMailer::Base
-          def welcome(*args)
-          end
-        end
-      end
+      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain in the first position" do
+        user_middleware1 = proc {}
+        add_middleware(user_middleware1)
+        described_class.new.install
+        user_middleware2 = proc {}
+        add_middleware(user_middleware2)
 
-      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
-          )
-        )
+        expect(Sidekiq.server_middleware).to eql([
+          Appsignal::Integrations::SidekiqMiddleware, # Prepend makes it the first entry
+          user_middleware1,
+          user_middleware2
+        ])
       end
     end
 
-    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
+    context "when Sidekiq middleware does not respond to prepend method" do
+      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithoutPrepend }
 
-    def perform_job(job_class, args)
-      perform_sidekiq { job_class.perform_later(args) }
-    end
+      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
+        user_middleware1 = proc {}
+        add_middleware(user_middleware1)
+        described_class.new.install
+        user_middleware2 = proc {}
+        add_middleware(user_middleware2)
 
-    def perform_mailer(mailer, method, args = nil)
-      perform_sidekiq { perform_action_mailer(mailer, method, args) }
+        # Add middlewares in whatever order they were added
+        expect(Sidekiq.server_middleware).to eql([
+          user_middleware1,
+          Appsignal::Integrations::SidekiqMiddleware,
+          user_middleware2
+        ])
+      end
     end
   end
 end