appsignal 2.10.6 → 2.11.0

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

@@ -263,7 +263,8 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           },
           "download" => {
             "download_url" => kind_of(String),
-            "checksum" => "verified"
+            "checksum" => "verified",
+            "http_proxy" => nil
           },
           "build" => {
             "time" => kind_of(String),
@@ -289,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"]}"}",
@@ -309,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

@@ -1,4 +1,18 @@
 describe Appsignal::Config do
+  describe "config keys" do
+    it "all config keys have an environment variable version registered" do
+      config = Appsignal::Config
+      mapped_env_keys = config::ENV_TO_KEY_MAPPING.keys.sort
+      configured_env_keys = (
+        config::ENV_STRING_KEYS +
+        config::ENV_BOOLEAN_KEYS +
+        config::ENV_ARRAY_KEYS
+      ).sort
+
+      expect(mapped_env_keys).to eql(configured_env_keys)
+    end
+  end
+
   describe "#initialize" do
     describe "environment" do
       context "when environment is nil" do
@@ -148,6 +162,7 @@ describe Appsignal::Config do
         :instrument_redis               => true,
         :instrument_sequel              => true,
         :skip_session_data              => false,
+        :send_environment_metadata      => true,
         :send_params                    => true,
         :endpoint                       => "https://push.appsignal.com",
         :push_api_key                   => "abc",
@@ -243,6 +258,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(
@@ -396,6 +432,7 @@ describe Appsignal::Config do
         :debug => true
       )
     end
+    let(:working_directory_path) { File.join(tmp_dir, "test_working_directory_path") }
     let(:env_config) do
       {
         :running_in_container => true,
@@ -411,7 +448,9 @@ describe Appsignal::Config do
         :instrument_sequel => false,
         :files_world_accessible => false,
         :request_headers => %w[accept accept-charset],
-        :revision => "v2.5.1"
+        :revision => "v2.5.1",
+        :send_environment_metadata => false,
+        :working_directory_path => working_directory_path
       }
     end
     before do
@@ -428,6 +467,8 @@ describe Appsignal::Config do
       ENV["APPSIGNAL_INSTRUMENT_SEQUEL"]       = "false"
       ENV["APPSIGNAL_FILES_WORLD_ACCESSIBLE"]  = "false"
       ENV["APPSIGNAL_REQUEST_HEADERS"]         = "accept,accept-charset"
+      ENV["APPSIGNAL_SEND_ENVIRONMENT_METADATA"] = "false"
+      ENV["APPSIGNAL_WORKING_DIRECTORY_PATH"] = working_directory_path
       ENV["APP_REVISION"] = "v2.5.1"
     end
 
@@ -527,6 +568,7 @@ describe Appsignal::Config do
       config[:running_in_container] = false
       config[:dns_servers] = ["8.8.8.8", "8.8.4.4"]
       config[:transaction_debug_mode] = true
+      config[:send_environment_metadata] = false
       config[:revision] = "v2.5.1"
       config.write_to_environment
     end
@@ -555,6 +597,7 @@ describe Appsignal::Config do
       expect(ENV["_APPSIGNAL_DNS_SERVERS"]).to                  eq "8.8.8.8,8.8.4.4"
       expect(ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]).to       eq "true"
       expect(ENV["_APPSIGNAL_TRANSACTION_DEBUG_MODE"]).to       eq "true"
+      expect(ENV["_APPSIGNAL_SEND_ENVIRONMENT_METADATA"]).to    eq "false"
       expect(ENV["_APP_REVISION"]).to                           eq "v2.5.1"
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIR_PATH")
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIRECTORY_PATH")

data/spec/lib/appsignal/environment_spec.rb

@@ -0,0 +1,167 @@
+describe Appsignal::Environment do
+  include EnvironmentMetadataHelper
+
+  before(:context) { start_agent }
+  before { capture_environment_metadata_report_calls }
+
+  def report(key, &value_block)
+    described_class.report(key, &value_block)
+  end
+
+  describe ".report" do
+    it "sends environment metadata to the extension" do
+      logs =
+        capture_logs do
+          report("_test_ruby_version") { "1.0.0" }
+          expect_environment_metadata("_test_ruby_version", "1.0.0")
+        end
+      expect(logs).to be_empty
+    end
+
+    context "when the key is a non String type" do
+      it "does not set the value" do
+        logs =
+          capture_logs do
+            report(:_test_symbol) { "1.0.0" }
+            expect_not_environment_metadata(:_test_symbol)
+            expect_not_environment_metadata("_test_symbol")
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata: Unsupported value type for :_test_symbol"
+        )
+      end
+    end
+
+    context "when the key is nil" do
+      it "does not set the value" do
+        logs =
+          capture_logs do
+            report(nil) { "1" }
+            expect_not_environment_metadata(nil)
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata: Unsupported value type for nil"
+        )
+      end
+    end
+
+    context "when the value is true or false" do
+      it "reports true or false as Strings" do
+        logs =
+          capture_logs do
+            report("_test_true") { true }
+            report("_test_false") { false }
+            expect_environment_metadata("_test_true", "true")
+            expect_environment_metadata("_test_false", "false")
+          end
+        expect(logs).to be_empty
+      end
+    end
+
+    context "when the value is nil" do
+      it "does not set the value" do
+        logs =
+          capture_logs do
+            report("_test_ruby_version") { nil }
+            expect_not_environment_metadata("_test_ruby_version")
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata \"_test_ruby_version\": " \
+            "Unsupported value type for nil"
+        )
+      end
+    end
+
+    context "when the value block raises an error" do
+      it "does not re-raise the error and writes it to the log" do
+        logs =
+          capture_logs do
+            report("_test_error") { raise "uh oh" }
+            expect_not_environment_metadata("_test_error")
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata \"_test_error\":\n" \
+            "RuntimeError: uh oh"
+        )
+      end
+    end
+
+    context "when something unforseen errors" do
+      it "does not re-raise the error and writes it to the log" do
+        klass = Class.new do
+          def inspect
+            raise "inspect error"
+          end
+        end
+
+        logs =
+          capture_logs do
+            report(klass.new) { raise "value error" }
+            expect(Appsignal::Extension).to_not have_received(:set_environment_metadata)
+          end
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report on environment metadata:\n" \
+            "RuntimeError: inspect error"
+        )
+      end
+    end
+  end
+
+  describe ".report_supported_gems" do
+    it "reports about all AppSignal supported gems in the bundle" do
+      logs = capture_logs { described_class.report_supported_gems }
+
+      expect(logs).to be_empty
+
+      bundle_gem_specs = ::Bundler.rubygems.all_specs
+      rack_spec = bundle_gem_specs.find { |s| s.name == "rack" }
+      rake_spec = bundle_gem_specs.find { |s| s.name == "rake" }
+      expect_environment_metadata("ruby_rack_version", rack_spec.version.to_s)
+      expect_environment_metadata("ruby_rake_version", rake_spec.version.to_s)
+      expect(rack_spec.version.to_s).to_not be_empty
+      expect(rake_spec.version.to_s).to_not be_empty
+    end
+
+    context "when something unforseen errors" do
+      it "does not re-raise the error and writes it to the log" do
+        expect(Bundler).to receive(:rubygems).and_raise(RuntimeError, "bundler error")
+
+        logs = capture_logs { described_class.report_supported_gems }
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report supported gems:\nRuntimeError: bundler error"
+        )
+      end
+    end
+  end
+
+  describe ".report_enabled" do
+    it "reports a feature being enabled" do
+      logs = capture_logs { described_class.report_enabled("a_test") }
+
+      expect(logs).to be_empty
+      expect_environment_metadata("ruby_a_test_enabled", "true")
+    end
+
+    context "when something unforseen errors" do
+      it "does not re-raise the error and writes it to the log" do
+        klass = Class.new do
+          def to_s
+            raise "to_s error"
+          end
+        end
+
+        logs = capture_logs { described_class.report_enabled(klass.new) }
+        expect(logs).to contains_log(
+          :error,
+          "Unable to report integration enabled:\nRuntimeError: to_s error"
+        )
+      end
+    end
+  end
+end

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