appsignal 2.11.0.alpha.2-java → 2.11.0.beta.5-java

data/lib/appsignal/integrations/resque_active_job.rb

@@ -4,38 +4,15 @@ module Appsignal
   module Integrations
     # @api private
     module ResqueActiveJobPlugin
-      include Appsignal::Hooks::Helpers
-
-      def self.included(base)
-        base.class_eval do
-          around_perform do |job, block|
-            params = Appsignal::Utils::HashSanitizer.sanitize(
-              job.arguments,
-              Appsignal.config[:filter_parameters]
-            )
-
-            queue_start =
-              if job.respond_to?(:enqueued_at) && job.enqueued_at
-                Time.parse(job.enqueued_at).utc
-              end
-
-            Appsignal.monitor_single_transaction(
-              "perform_job.resque",
-              :class       => job.class.to_s,
-              :method      => "perform",
-              :params      => params,
-              :queue_start => queue_start,
-              :metadata    => {
-                :id       => job.job_id,
-                :queue    => job.queue_name
-              }
-            ) do
-              block.call
-            end
-          end
-        end
-
-        Appsignal::Environment.report("ruby_active_job_resque_enabled") { true }
+      def self.included(_)
+        callers = caller
+        Appsignal::Utils::DeprecationMessage.message \
+          "The AppSignal ResqueActiveJobPlugin is deprecated and does " \
+          "nothing on extend. In this version of the AppSignal Ruby gem " \
+          "the integration with Resque is automatic on all Resque workers. " \
+          "Please remove the following line from this file to remove this " \
+          "message: include Appsignal::Integrations::ResqueActiveJobPlugin\n" \
+          "#{callers.first}"
       end
     end
   end

data/lib/appsignal/probes.rb

@@ -0,0 +1,7 @@
+module Appsignal
+  module Probes
+  end
+end
+
+require "appsignal/probes/puma"
+require "appsignal/probes/sidekiq"

data/lib/appsignal/probes/puma.rb

@@ -1,11 +1,11 @@
 module Appsignal
   module Probes
-    # @api private
     class PumaProbe
       def initialize
         @hostname = Appsignal.config[:hostname] || Socket.gethostname
       end
 
+      # @api private
       def call
         puma_stats = fetch_puma_stats
         return unless puma_stats

data/lib/appsignal/probes/sidekiq.rb

@@ -1,9 +1,10 @@
 module Appsignal
   module Probes
-    # @api private
     class SidekiqProbe
+      # @api private
       attr_reader :config
 
+      # @api private
       def self.dependencies_present?
         Gem::Version.new(::Redis::VERSION) >= Gem::Version.new("3.3.5")
       end
@@ -16,6 +17,7 @@ module Appsignal
         require "sidekiq/api"
       end
 
+      # @api private
       def call
         track_redis_info
         track_stats

data/lib/appsignal/transaction.rb

@@ -221,6 +221,16 @@ module Appsignal
       set_action_if_nil(group_and_action.compact.join("#"))
     end
 
+    # Set queue start time for transaction.
+    #
+    # Most commononly called by {set_http_or_background_queue_start}.
+    #
+    # @param start [Integer] Queue start time in milliseconds.
+    # @raise [RangeError] When the queue start time value is too big, this
+    #   method raises a RangeError.
+    # @raise [TypeError] Raises a TypeError when the given `start` argument is
+    #   not an Integer.
+    # @return [void]
     def set_queue_start(start)
       return unless start
       @ext.set_queue_start(start)

data/lib/appsignal/utils/deprecation_message.rb

@@ -1,10 +1,14 @@
 module Appsignal
   module Utils
     module DeprecationMessage
-      def deprecation_message(message, logger = Appsignal.logger)
-        $stderr.puts "appsignal WARNING: #{message}"
+      def self.message(message, logger = Appsignal.logger)
+        Kernel.warn "appsignal WARNING: #{message}"
         logger.warn message
       end
+
+      def deprecation_message(message, logger = Appsignal.logger)
+        Appsignal::Utils::DeprecationMessage.message(message, logger)
+      end
     end
   end
 end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.11.0.alpha.2".freeze
+  VERSION = "2.11.0.beta.5".freeze
 end

data/spec/lib/appsignal/auth_check_spec.rb

@@ -28,6 +28,29 @@ describe Appsignal::AuthCheck do
     end.join("&")
   end
 
+  describe ".new" do
+    describe "with logger argument" do
+      let(:err_stream) { std_stream }
+      let(:stderr) { err_stream.read }
+      let(:log_stream) { std_stream }
+      let(:log) { log_contents(log_stream) }
+
+      it "logs and prints a deprecation message" do
+        Appsignal.logger = test_logger(log_stream)
+
+        capture_std_streams(std_stream, err_stream) do
+          Appsignal::AuthCheck.new(config, Appsignal.logger)
+        end
+
+        deprecation_message =
+          "`Appsignal::AuthCheck.new`'s `logger` argument " \
+          "will be removed in the next major version."
+        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
+        expect(log).to contains_log :warn, deprecation_message
+      end
+    end
+  end
+
   describe "#perform" do
     subject { auth_check.perform }
 

data/spec/lib/appsignal/capistrano2_spec.rb

@@ -10,7 +10,7 @@ if DependencyHelper.capistrano2_present?
     let(:capistrano_config) do
       Capistrano::Configuration.new.tap do |c|
         c.set(:rails_env, "production")
-        c.set(:repository, "master")
+        c.set(:repository, "main")
         c.set(:deploy_to, "/home/username/app")
         c.set(:current_release, "")
         c.set(:current_revision, "503ce0923ed177a3ce000005")

data/spec/lib/appsignal/capistrano3_spec.rb

@@ -15,7 +15,7 @@ if DependencyHelper.capistrano3_present?
         c.set(:log_level, :error)
         c.set(:logger, logger)
         c.set(:rails_env, "production")
-        c.set(:repository, "master")
+        c.set(:repository, "main")
         c.set(:deploy_to, "/home/username/app")
         c.set(:current_release, "")
         c.set(:current_revision, "503ce0923ed177a3ce000005")

data/spec/lib/appsignal/cli/diagnose_spec.rb

@@ -290,6 +290,8 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         jruby = Appsignal::System.jruby?
         expect(output).to include(
           "Extension installation report",
+          "Installation result",
+          "  Status: success",
           "Language details",
           "  Implementation: #{jruby ? "jruby" : "ruby"}",
           "  Ruby version: #{"#{rbconfig["ruby_version"]}-p#{rbconfig["PATCHLEVEL"]}"}",
@@ -310,6 +312,46 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         )
       end
 
+      context "with error in install report" do
+        let(:error) { RuntimeError.new("some error") }
+        before do
+          allow(File).to receive(:read).and_call_original
+          expect(File).to receive(:read)
+            .with(File.expand_path("../../../../../ext/install.report", __FILE__))
+            .and_return(
+              YAML.dump(
+                "result" => {
+                  "status" => "error",
+                  "error" => "RuntimeError: some error",
+                  "backtrace" => error.backtrace
+                }
+              )
+            )
+        end
+
+        it "sends an error" do
+          run
+          expect(received_report["installation"]).to match(
+            "result" => {
+              "status" => "error",
+              "error" => "RuntimeError: some error",
+              "backtrace" => error.backtrace
+            }
+          )
+        end
+
+        it "prints the error" do
+          run
+
+          expect(output).to include(
+            "Extension installation report",
+            "Installation result",
+            "Status: error\n    Error: RuntimeError: some error"
+          )
+          expect(output).to_not include("Raw report:")
+        end
+      end
+
       context "without install report" do
         let(:error) { RuntimeError.new("foo") }
         before do

data/spec/lib/appsignal/config_spec.rb

@@ -244,6 +244,27 @@ describe Appsignal::Config do
       end
     end
 
+    context "with an overriden config file" do
+      let(:config) do
+        project_fixture_config("production", {}, Appsignal.logger, File.join(project_fixture_path, "config", "appsignal.yml"))
+      end
+
+      it "is valid and active" do
+        expect(config.valid?).to be_truthy
+        expect(config.active?).to be_truthy
+      end
+
+      context "with an invalid overriden config file" do
+        let(:config) do
+          project_fixture_config("production", {}, Appsignal.logger, File.join(project_fixture_path, "config", "missing.yml"))
+        end
+
+        it "is not valid" do
+          expect(config.valid?).to be_falsy
+        end
+      end
+    end
+
     context "with the config file causing an error" do
       let(:config_path) do
         File.expand_path(

data/spec/lib/appsignal/extension/jruby_spec.rb

@@ -1,42 +1,45 @@
-if Appsignal::System.jruby?
-  describe Appsignal::Extension::Jruby do
-    let(:extension) { Appsignal::Extension }
+describe "JRuby extension", :jruby do
+  let(:extension) { Appsignal::Extension }
+  let(:jruby_module) { Appsignal::Extension::Jruby }
 
-    describe "string conversions" do
-      it "keeps the same value during string type conversions" do
-        # UTF-8 string with NULL
-        # Tests if the conversions between the conversions without breaking on
-        # NULL terminated strings in C.
-        string = "Merry Christmas! \u0000 🎄"
+  it "creates a JRuby extension module" do
+    expect(Appsignal::Extension::Jruby).to be_kind_of(Module)
+  end
 
-        appsignal_string = extension.make_appsignal_string(string)
-        ruby_string = extension.make_ruby_string(appsignal_string)
+  describe "string conversions" do
+    it "keeps the same value during string type conversions" do
+      # UTF-8 string with NULL
+      # Tests if the conversions between the conversions without breaking on
+      # NULL terminated strings in C.
+      string = "Merry Christmas! \u0000 🎄"
 
-        expect(ruby_string).to eq("Merry Christmas! \u0000 🎄")
-      end
-    end
+      appsignal_string = extension.make_appsignal_string(string)
+      ruby_string = extension.make_ruby_string(appsignal_string)
 
-    it "loads libappsignal with FFI" do
-      expect(described_class.ffi_libraries.map(&:name).first).to include "libappsignal"
+      expect(ruby_string).to eq("Merry Christmas! \u0000 🎄")
     end
+  end
 
-    describe ".lib_extension" do
-      subject { described_class.lib_extension }
+  it "loads libappsignal with FFI" do
+    expect(jruby_module.ffi_libraries.map(&:name).first).to include "libappsignal"
+  end
+
+  describe ".lib_extension" do
+    subject { jruby_module.lib_extension }
 
-      context "when on a darwin system" do
-        before { expect(Appsignal::System).to receive(:agent_platform).and_return("darwin") }
+    context "when on a darwin system" do
+      before { expect(Appsignal::System).to receive(:agent_platform).and_return("darwin") }
 
-        it "returns the extension for darwin" do
-          is_expected.to eq "dylib"
-        end
+      it "returns the extension for darwin" do
+        is_expected.to eq "dylib"
       end
+    end
 
-      context "when on a linux system" do
-        before { expect(Appsignal::System).to receive(:agent_platform).and_return("linux") }
+    context "when on a linux system" do
+      before { expect(Appsignal::System).to receive(:agent_platform).and_return("linux") }
 
-        it "returns the lib extension for linux" do
-          is_expected.to eq "so"
-        end
+      it "returns the lib extension for linux" do
+        is_expected.to eq "so"
       end
     end
   end

data/spec/lib/appsignal/extension_install_failure_spec.rb

@@ -0,0 +1,23 @@
+describe Appsignal::Extension, :extension_installation_failure do
+  context "when the extension library cannot be loaded" do
+    # This test breaks the installation on purpose and is not run by default.
+    # See `rake test:failure`. If this test was run, run `rake
+    # extension:install` again to fix the extension installation.
+    it "prints and logs an error" do
+      # ENV var to make sure installation fails on purpurse
+      ENV["_TEST_APPSIGNAL_EXTENSION_FAILURE"] = "true"
+      `rake extension:install` # Run installation
+
+      require "open3"
+      _stdout, stderr, _status = Open3.capture3("bin/appsignal --version")
+      expect(stderr).to include("ERROR: AppSignal failed to load extension")
+      error_message =
+        if DependencyHelper.running_jruby?
+          "cannot open shared object file"
+        else
+          "LoadError: cannot load such file"
+        end
+      expect(stderr).to include(error_message)
+    end
+  end
+end

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

@@ -0,0 +1,591 @@
+if DependencyHelper.active_job_present?
+  require "active_job"
+  require "action_mailer"
+
+  describe Appsignal::Hooks::ActiveJobHook do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      context "when ActiveJob constant is found" do
+        before { stub_const "ActiveJob", Class.new }
+
+        it { is_expected.to be_truthy }
+      end
+
+      context "when ActiveJob constant is not found" do
+        before { hide_const "ActiveJob" }
+
+        it { is_expected.to be_falsy }
+      end
+    end
+
+    describe "#install" do
+      it "extends ActiveJob::Base with the AppSignal ActiveJob plugin" do
+        start_agent
+
+        path, _line_number = ActiveJob::Base.method(:execute).source_location
+        expect(path).to end_with("/lib/appsignal/hooks/active_job.rb")
+      end
+    end
+  end
+
+  describe Appsignal::Hooks::ActiveJobHook::ActiveJobClassInstrumentation do
+    let(:time) { Time.parse("2001-01-01 10:00:00UTC") }
+    let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+    let(:queue) { "default" }
+    let(:log) { StringIO.new }
+    let(:parameterized_given_args) do
+      {
+        :foo => "Foo",
+        "bar" => "Bar",
+        "baz" => { "1" => "foo" }
+      }
+    end
+    let(:method_given_args) do
+      [
+        "foo",
+        parameterized_given_args
+      ]
+    end
+    let(:parameterized_expected_args) do
+      {
+        "_aj_symbol_keys" => ["foo"],
+        "foo" => "Foo",
+        "bar" => "Bar",
+        "baz" => {
+          "_aj_symbol_keys" => [],
+          "1" => "foo"
+        }
+      }
+    end
+    let(:method_expected_args) do
+      [
+        "foo",
+        parameterized_expected_args
+      ]
+    end
+    before do
+      ActiveJob::Base.queue_adapter = :inline
+
+      start_agent
+      Appsignal.logger = test_logger(log)
+      class ActiveJobTestJob < ActiveJob::Base
+        def perform(*_args)
+        end
+      end
+
+      class ActiveJobErrorTestJob < ActiveJob::Base
+        def perform
+          raise "uh oh"
+        end
+      end
+
+      class ActiveJobCustomQueueTestJob < ActiveJob::Base
+        queue_as :custom_queue
+
+        def perform(*_args)
+        end
+      end
+    end
+    around { |example| keep_transactions { example.run } }
+    after do
+      Object.send(:remove_const, :ActiveJobTestJob)
+      Object.send(:remove_const, :ActiveJobErrorTestJob)
+      Object.send(:remove_const, :ActiveJobCustomQueueTestJob)
+    end
+
+    it "reports the name from the ActiveJob integration" do
+      tags = { :queue => queue }
+      expect(Appsignal).to receive(:increment_counter)
+        .with("active_job_queue_job_count", 1, tags.merge(:status => :processed))
+
+      perform_job(ActiveJobTestJob)
+
+      transaction = last_transaction
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "ActiveJobTestJob#perform",
+        "error" => nil,
+        "namespace" => namespace,
+        "metadata" => {},
+        "sample_data" => hash_including(
+          "params" => [],
+          "tags" => {
+            "active_job_id" => kind_of(String),
+            "queue" => queue
+          }
+        )
+      )
+      events = transaction_hash["events"]
+        .sort_by { |e| e["start"] }
+        .map { |event| event["name"] }
+      expect(events).to eq(["perform_start.active_job", "perform.active_job"])
+    end
+
+    context "with custom queue" do
+      it "reports the custom queue as tag on the transaction" do
+        tags = { :queue => "custom_queue" }
+        expect(Appsignal).to receive(:increment_counter)
+          .with("active_job_queue_job_count", 1, tags.merge(:status => :processed))
+        perform_job(ActiveJobCustomQueueTestJob)
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "sample_data" => hash_including(
+            "tags" => hash_including("queue" => "custom_queue")
+          )
+        )
+      end
+    end
+
+    if DependencyHelper.rails_version >= Gem::Version.new("5.0.0")
+      context "with priority" do
+        before do
+          class ActiveJobPriorityTestJob < ActiveJob::Base
+            queue_with_priority 10
+
+            def perform(*_args)
+            end
+          end
+        end
+        after do
+          Object.send(:remove_const, :ActiveJobPriorityTestJob)
+        end
+
+        it "reports the priority as tag on the transaction" do
+          tags = { :queue => queue }
+          expect(Appsignal).to receive(:increment_counter)
+            .with("active_job_queue_job_count", 1, tags.merge(:status => :processed))
+          expect(Appsignal).to receive(:increment_counter)
+            .with("active_job_queue_priority_job_count", 1, tags.merge(:priority => 10, :status => :processed))
+
+          perform_job(ActiveJobPriorityTestJob)
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "sample_data" => hash_including(
+              "tags" => hash_including("queue" => queue, "priority" => 10)
+            )
+          )
+        end
+      end
+    end
+
+    context "with error" do
+      it "reports the error on the transaction from the ActiveRecord integration" do
+        allow(Appsignal).to receive(:increment_counter) # Other calls we're testing in another test
+        tags = { :queue => queue }
+        expect(Appsignal).to receive(:increment_counter)
+          .with("active_job_queue_job_count", 1, tags.merge(:status => :failed))
+        expect(Appsignal).to receive(:increment_counter)
+          .with("active_job_queue_job_count", 1, tags.merge(:status => :processed))
+
+        expect do
+          perform_job(ActiveJobErrorTestJob)
+        end.to raise_error(RuntimeError, "uh oh")
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "action" => "ActiveJobErrorTestJob#perform",
+          "error" => {
+            "name" => "RuntimeError",
+            "message" => "uh oh",
+            "backtrace" => kind_of(String)
+          },
+          "namespace" => namespace,
+          "metadata" => {},
+          "sample_data" => hash_including(
+            "params" => [],
+            "tags" => {
+              "active_job_id" => kind_of(String),
+              "queue" => queue
+            }
+          )
+        )
+        events = transaction_hash["events"]
+          .sort_by { |e| e["start"] }
+          .map { |event| event["name"] }
+        expect(events).to eq(["perform_start.active_job", "perform.active_job"])
+      end
+
+      if DependencyHelper.rails_version >= Gem::Version.new("5.0.0")
+        context "with priority" do
+          before do
+            class ActiveJobErrorPriorityTestJob < ActiveJob::Base
+              queue_with_priority 10
+
+              def perform(*_args)
+                raise "uh oh"
+              end
+            end
+          end
+          after do
+            Object.send(:remove_const, :ActiveJobErrorPriorityTestJob)
+          end
+
+          it "reports the priority as tag on the transaction" do
+            tags = { :queue => queue }
+            expect(Appsignal).to receive(:increment_counter)
+              .with("active_job_queue_job_count", 1, tags.merge(:status => :processed))
+            expect(Appsignal).to receive(:increment_counter)
+              .with("active_job_queue_job_count", 1, tags.merge(:status => :failed))
+            expect(Appsignal).to receive(:increment_counter)
+              .with("active_job_queue_priority_job_count", 1, tags.merge(:priority => 10, :status => :processed))
+            expect(Appsignal).to receive(:increment_counter)
+              .with("active_job_queue_priority_job_count", 1, tags.merge(:priority => 10, :status => :failed))
+
+            expect do
+              perform_job(ActiveJobErrorPriorityTestJob)
+            end.to raise_error(RuntimeError, "uh oh")
+
+            transaction = last_transaction
+            transaction_hash = transaction.to_h
+            expect(transaction_hash).to include(
+              "sample_data" => hash_including(
+                "tags" => hash_including("queue" => queue, "priority" => 10)
+              )
+            )
+          end
+        end
+      end
+    end
+
+    context "when wrapped in another transaction" do
+      it "does not create a new transaction or close the currently open one" do
+        current_transaction = background_job_transaction
+        allow(current_transaction).to receive(:complete).and_call_original
+        set_current_transaction current_transaction
+
+        perform_job(ActiveJobTestJob)
+
+        expect(created_transactions.count).to eql(1)
+        expect(current_transaction).to_not have_received(:complete)
+        current_transaction.complete
+
+        transaction = current_transaction
+        transaction_hash = transaction.to_h
+        # It does set data on the transaction
+        expect(transaction_hash).to include(
+          "id" => current_transaction.transaction_id,
+          "action" => "ActiveJobTestJob#perform",
+          "error" => nil,
+          "namespace" => namespace,
+          "metadata" => {},
+          "sample_data" => hash_including(
+            "params" => [],
+            "tags" => {
+              "active_job_id" => kind_of(String),
+              "queue" => queue
+            }
+          )
+        )
+        events = transaction_hash["events"]
+          .reject { |e| e["name"] == "enqueue.active_job" }
+          .sort_by { |e| e["start"] }
+          .map { |event| event["name"] }
+        expect(events).to eq(["perform_start.active_job", "perform.active_job"])
+      end
+    end
+
+    context "with params" do
+      it "filters the configured params" do
+        Appsignal.config = project_fixture_config("production")
+        Appsignal.config[:filter_parameters] = ["foo"]
+        perform_job(ActiveJobTestJob, method_given_args)
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash["sample_data"]["params"]).to include(
+          [
+            "foo",
+            {
+              "_aj_symbol_keys" => ["foo"],
+              "foo" => "[FILTERED]",
+              "bar" => "Bar",
+              "baz" => { "_aj_symbol_keys" => [], "1" => "foo" }
+            }
+          ]
+        )
+      end
+    end
+
+    context "with provider_job_id", :skip => DependencyHelper.rails_version < Gem::Version.new("5.0.0") do
+      before do
+        module ActiveJob
+          module QueueAdapters
+            # Adapter used in our test suite to add provider data to the job
+            # data, as is done by Rails provided ActiveJob adapters.
+            #
+            # This implementation is based on the
+            # `ActiveJob::QueueAdapters::InlineAdapter`.
+            class AppsignalTestAdapter < InlineAdapter
+              def enqueue(job)
+                Base.execute(job.serialize.merge("provider_job_id" => "my_provider_job_id"))
+              end
+            end
+          end
+        end
+
+        class ProviderWrappedActiveJobTestJob < ActiveJob::Base
+          self.queue_adapter = :appsignal_test
+
+          def perform(*_args)
+          end
+        end
+      end
+      after do
+        ActiveJob::QueueAdapters.send(:remove_const, :AppsignalTestAdapter)
+        Object.send(:remove_const, :ProviderWrappedActiveJobTestJob)
+      end
+
+      it "sets provider_job_id as tag" do
+        perform_job(ProviderWrappedActiveJobTestJob)
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash["sample_data"]["tags"]).to include(
+          "provider_job_id" => "my_provider_job_id"
+        )
+      end
+    end
+
+    context "with enqueued_at", :skip => DependencyHelper.rails_version < Gem::Version.new("6.0.0") do
+      before do
+        module ActiveJob
+          module QueueAdapters
+            # Adapter used in our test suite to add provider data to the job
+            # data, as is done by Rails provided ActiveJob adapters.
+            #
+            # This implementation is based on the
+            # `ActiveJob::QueueAdapters::InlineAdapter`.
+            class AppsignalTestAdapter < InlineAdapter
+              def enqueue(job)
+                Base.execute(job.serialize.merge("enqueued_at" => "2020-10-10T10:10:10Z"))
+              end
+            end
+          end
+        end
+
+        class ProviderWrappedActiveJobTestJob < ActiveJob::Base
+          self.queue_adapter = :appsignal_test
+
+          def perform(*_args)
+          end
+        end
+      end
+      after do
+        ActiveJob::QueueAdapters.send(:remove_const, :AppsignalTestAdapter)
+        Object.send(:remove_const, :ProviderWrappedActiveJobTestJob)
+      end
+
+      it "sets queue time on transaction" do
+        allow_any_instance_of(Appsignal::Transaction).to receive(:set_queue_start).and_call_original
+        perform_job(ProviderWrappedActiveJobTestJob)
+
+        transaction = last_transaction
+        queue_time = Time.parse("2020-10-10T10:10:10Z")
+        expect(transaction).to have_received(:set_queue_start)
+          .with((queue_time.to_f * 1_000).to_i)
+      end
+    end
+
+    context "with ActionMailer job" do
+      include ActionMailerHelpers
+
+      before do
+        class ActionMailerTestJob < ActionMailer::Base
+          def welcome(_first_arg = nil, _second_arg = nil)
+          end
+        end
+      end
+      after do
+        Object.send(:remove_const, :ActionMailerTestJob)
+      end
+
+      context "without params" do
+        it "sets the Action mailer data on the transaction" do
+          perform_mailer(ActionMailerTestJob, :welcome)
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "action" => "ActionMailerTestJob#welcome",
+            "sample_data" => hash_including(
+              "params" => ["ActionMailerTestJob", "welcome", "deliver_now"],
+              "tags" => {
+                "active_job_id" => kind_of(String),
+                "queue" => "mailers"
+              }
+            )
+          )
+        end
+      end
+
+      context "with multiple arguments" do
+        it "sets the arguments on the transaction" do
+          perform_mailer(ActionMailerTestJob, :welcome, method_given_args)
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "action" => "ActionMailerTestJob#welcome",
+            "sample_data" => hash_including(
+              "params" => ["ActionMailerTestJob", "welcome", "deliver_now"] + method_expected_args,
+              "tags" => {
+                "active_job_id" => kind_of(String),
+                "queue" => "mailers"
+              }
+            )
+          )
+        end
+      end
+
+      if DependencyHelper.rails_version >= Gem::Version.new("5.2.0")
+        context "with parameterized arguments" do
+          it "sets the arguments on the transaction" do
+            perform_mailer(ActionMailerTestJob, :welcome, parameterized_given_args)
+
+            transaction = last_transaction
+            transaction_hash = transaction.to_h
+            expect(transaction_hash).to include(
+              "action" => "ActionMailerTestJob#welcome",
+              "sample_data" => hash_including(
+                "params" => ["ActionMailerTestJob", "welcome", "deliver_now", parameterized_expected_args],
+                "tags" => {
+                  "active_job_id" => kind_of(String),
+                  "queue" => "mailers"
+                }
+              )
+            )
+          end
+        end
+      end
+    end
+
+    if DependencyHelper.rails_version >= Gem::Version.new("6.0.0")
+      context "with ActionMailer MailDeliveryJob job" do
+        include ActionMailerHelpers
+
+        before do
+          class ActionMailerTestMailDeliveryJob < ActionMailer::Base
+            self.delivery_job = ActionMailer::MailDeliveryJob
+
+            def welcome(*_args)
+            end
+          end
+        end
+        after do
+          Object.send(:remove_const, :ActionMailerTestMailDeliveryJob)
+        end
+
+        it "sets the Action mailer data on the transaction" do
+          perform_mailer(ActionMailerTestMailDeliveryJob, :welcome)
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "action" => "ActionMailerTestMailDeliveryJob#welcome",
+            "sample_data" => hash_including(
+              "params" => [
+                "ActionMailerTestMailDeliveryJob",
+                "welcome",
+                "deliver_now",
+                { active_job_internal_key => ["args"], "args" => [] }
+              ],
+              "tags" => {
+                "active_job_id" => kind_of(String),
+                "queue" => "mailers"
+              }
+            )
+          )
+        end
+
+        context "with method arguments" do
+          it "sets the Action mailer data on the transaction" do
+            perform_mailer(ActionMailerTestMailDeliveryJob, :welcome, method_given_args)
+
+            transaction = last_transaction
+            transaction_hash = transaction.to_h
+            expect(transaction_hash).to include(
+              "action" => "ActionMailerTestMailDeliveryJob#welcome",
+              "sample_data" => hash_including(
+                "params" => [
+                  "ActionMailerTestMailDeliveryJob",
+                  "welcome",
+                  "deliver_now",
+                  {
+                    active_job_internal_key => ["args"],
+                    "args" => method_expected_args
+                  }
+                ],
+                "tags" => {
+                  "active_job_id" => kind_of(String),
+                  "queue" => "mailers"
+                }
+              )
+            )
+          end
+        end
+
+        context "with parameterized arguments" do
+          it "sets the Action mailer data on the transaction" do
+            perform_mailer(ActionMailerTestMailDeliveryJob, :welcome, parameterized_given_args)
+
+            transaction = last_transaction
+            transaction_hash = transaction.to_h
+            expect(transaction_hash).to include(
+              "action" => "ActionMailerTestMailDeliveryJob#welcome",
+              "sample_data" => hash_including(
+                "params" => [
+                  "ActionMailerTestMailDeliveryJob",
+                  "welcome",
+                  "deliver_now",
+                  {
+                    active_job_internal_key => ["params", "args"],
+                    "args" => [],
+                    "params" => parameterized_expected_args
+                  }
+                ],
+                "tags" => {
+                  "active_job_id" => kind_of(String),
+                  "queue" => "mailers"
+                }
+              )
+            )
+          end
+        end
+      end
+    end
+
+    def perform_active_job
+      Timecop.freeze(time) do
+        yield
+      end
+    end
+
+    def perform_job(job_class, args = nil)
+      perform_active_job do
+        if args
+          job_class.perform_later(args)
+        else
+          job_class.perform_later
+        end
+      end
+    end
+
+    def perform_mailer(mailer, method, args = nil)
+      perform_active_job { perform_action_mailer(mailer, method, args) }
+    end
+
+    def active_job_internal_key
+      if DependencyHelper.ruby_version >= Gem::Version.new("2.7.0")
+        "_aj_ruby2_keywords"
+      else
+        "_aj_symbol_keys"
+      end
+    end
+  end
+end