appsignal 2.10.6 → 2.11.0.alpha.1

data/lib/appsignal/extension/jruby.rb

@@ -60,6 +60,9 @@ module Appsignal
           [:appsignal_string],
           :appsignal_string
         attach_function :appsignal_running_in_container, [], :bool
+        attach_function :appsignal_set_environment_metadata,
+          [:appsignal_string, :appsignal_string],
+          :void
 
         # Metrics methods
         attach_function :appsignal_set_gauge,
@@ -224,6 +227,13 @@ module Appsignal
         appsignal_running_in_container
       end
 
+      def set_environment_metadata(key, value)
+        appsignal_set_environment_metadata(
+          make_appsignal_string(key),
+          make_appsignal_string(value)
+        )
+      end
+
       def set_gauge(key, value, tags)
         appsignal_set_gauge(make_appsignal_string(key), value, tags.pointer)
       end

data/lib/appsignal/hooks/net_http.rb

@@ -13,23 +13,20 @@ module Appsignal
       end
 
       def install
-        if Appsignal::System.ruby_2_or_up?
-          require "appsignal/integrations/net_http"
-          Net::HTTP.send(:prepend, Appsignal::Integrations::NetHttpIntegration)
-        else
-          Net::HTTP.class_eval do
-            alias request_without_appsignal request
+        Net::HTTP.class_eval do
+          alias request_without_appsignal request
 
-            def request(request, body = nil, &block)
-              Appsignal.instrument(
-                "request.net_http",
-                "#{request.method} #{use_ssl? ? "https" : "http"}://#{request["host"] || address}"
-              ) do
-                request_without_appsignal(request, body, &block)
-              end
+          def request(request, body = nil, &block)
+            Appsignal.instrument(
+              "request.net_http",
+              "#{request.method} #{use_ssl? ? "https" : "http"}://#{request["host"] || address}"
+            ) do
+              request_without_appsignal(request, body, &block)
             end
           end
         end
+
+        Appsignal::Environment.report_enabled("net_http")
       end
     end
   end

data/lib/appsignal/hooks/redis.rb

@@ -26,6 +26,8 @@ module Appsignal
             end
           end
         end
+
+        Appsignal::Environment.report_enabled("redis")
       end
     end
   end

data/lib/appsignal/hooks/sequel.rb

@@ -56,6 +56,8 @@ module Appsignal
 
         # ... and automatically add it to future instances.
         ::Sequel::Database.extension(:appsignal_integration)
+
+        Appsignal::Environment.report_enabled("sequel")
       end
     end
   end

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -27,9 +27,8 @@ module Appsignal
           method_name = "perform"
         else
           # Delayed Job
-          args = extract_value(job.payload_object, :args, {})
-          class_and_method_name = extract_value(job.payload_object, :appsignal_name, job.name)
-          class_name, method_name = class_and_method_name.split("#")
+          args = extract_value(payload, :args, {})
+          class_name, method_name = class_and_method_name_from_object_or_hash(payload, job.name)
         end
 
         params = Appsignal::Utils::HashSanitizer.sanitize(
@@ -54,6 +53,20 @@ module Appsignal
         end
       end
 
+      def self.class_and_method_name_from_object_or_hash(payload, default_name)
+        # Attempt to find appsignal_name override
+        class_and_method_name = extract_value(payload, :appsignal_name, nil)
+        return class_and_method_name.split("#") if class_and_method_name.is_a?(String)
+
+        pound_split = default_name.split("#")
+        return pound_split if pound_split.length == 2
+
+        dot_split = default_name.split(".")
+        return default_name if dot_split.length == 2
+
+        ["unknown"]
+      end
+
       def self.extract_value(object_or_hash, field, default_value = nil, convert_to_s = false)
         value = nil
 

data/lib/appsignal/integrations/object.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+if defined?(Appsignal)
+  Appsignal::Environment.report_enabled("object_instrumentation")
+end
+
 class Object
   def self.appsignal_instrument_class_method(method_name, options = {})
     singleton_class.send \

data/lib/appsignal/integrations/resque_active_job.rb

@@ -14,12 +14,18 @@ module Appsignal
               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,
-              :metadata => {
+              :class       => job.class.to_s,
+              :method      => "perform",
+              :params      => params,
+              :queue_start => queue_start,
+              :metadata    => {
                 :id       => job.job_id,
                 :queue    => job.queue_name
               }
@@ -28,6 +34,8 @@ module Appsignal
             end
           end
         end
+
+        Appsignal::Environment.report("ruby_active_job_resque_enabled") { true }
       end
     end
   end

data/lib/appsignal/system.rb

@@ -76,14 +76,8 @@ module Appsignal
       ldd_version && ldd_version[0]
     end
 
-    # @api private
     def self.jruby?
       RUBY_PLATFORM == "java"
     end
-
-    # @api private
-    def self.ruby_2_or_up?
-      versionify(RUBY_VERSION) >= versionify("2.0")
-    end
   end
 end

data/lib/appsignal/transaction.rb

@@ -228,12 +228,27 @@ module Appsignal
       Appsignal.logger.warn("Queue start value #{start} is too big")
     end
 
+    # Set the queue time based on the HTTP header or `:queue_start` env key
+    # value.
+    #
+    # This method will first try to read the queue time from the HTTP headers
+    # `X-Request-Start` or `X-Queue-Start`. Which are parsed by Rack as
+    # `HTTP_X_QUEUE_START` and `HTTP_X_REQUEST_START`.
+    # The header value is parsed by AppSignal as either milliseconds or
+    # microseconds.
+    #
+    # If no headers are found, or the value could not be parsed, it falls back
+    # on the `:queue_start` env key on this Transaction's {request} environment
+    # (called like `request.env[:queue_start]`). This value is parsed by
+    # AppSignal as seconds.
+    #
+    # @see https://docs.appsignal.com/ruby/instrumentation/request-queue-time.html
+    # @return [void]
     def set_http_or_background_queue_start
-      if namespace == HTTP_REQUEST
-        set_queue_start(http_queue_start)
-      elsif namespace == BACKGROUND_JOB
-        set_queue_start(background_queue_start)
-      end
+      start = http_queue_start || background_queue_start
+      return unless start
+
+      set_queue_start(start)
     end
 
     def set_metadata(key, value)
@@ -346,14 +361,14 @@ module Appsignal
     #
     # @return [nil] if no {#environment} is present.
     # @return [nil] if there is no `:queue_start` in the {#environment}.
-    # @return [Integer]
+    # @return [Integer] `:queue_start` time (in seconds) converted to milliseconds
     def background_queue_start
       env = environment
       return unless env
       queue_start = env[:queue_start]
       return unless queue_start
 
-      (queue_start.to_f * 1000.0).to_i
+      (queue_start.to_f * 1000.0).to_i # Convert seconds to milliseconds
     end
 
     # Returns HTTP queue start time in milliseconds.

data/lib/appsignal/version.rb

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

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),

data/spec/lib/appsignal/config_spec.rb

@@ -148,6 +148,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",
@@ -411,7 +412,8 @@ 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
       }
     end
     before do
@@ -428,6 +430,7 @@ 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["APP_REVISION"] = "v2.5.1"
     end
 
@@ -527,6 +530,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 +559,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/hooks/delayed_job_spec.rb

@@ -36,6 +36,7 @@ describe Appsignal::Hooks::DelayedJobHook do
       let(:time) { Time.parse("01-01-2001 10:01:00UTC") }
       let(:created_at) { time - 3600 }
       let(:run_at) { time - 3600 }
+      let(:payload_object) { double(:args => args) }
       let(:job_data) do
         {
           :id             => 123,
@@ -45,38 +46,40 @@ describe Appsignal::Hooks::DelayedJobHook do
           :queue          => "default",
           :created_at     => created_at,
           :run_at         => run_at,
-          :payload_object => double(:args => args)
+          :payload_object => payload_object
         }
       end
       let(:args) { ["argument"] }
       let(:job) { double(job_data) }
       let(:invoked_block) { proc {} }
 
-      context "with a normal call" do
-        let(:default_params) do
-          {
-            :class    => "TestClass",
-            :method   => "perform",
-            :metadata => {
-              :priority => 1,
-              :attempts => 1,
-              :queue    => "default",
-              :id       => "123"
-            },
-            :params      => args,
-            :queue_start => run_at
-          }
-        end
-        after do
-          Timecop.freeze(time) do
+      def perform
+        Timecop.freeze(time) do
+          keep_transactions do
             plugin.invoke_with_instrumentation(job, invoked_block)
           end
         end
+      end
 
-        it "wraps it in a transaction with the correct params" do
-          expect(Appsignal).to receive(:monitor_transaction).with(
-            "perform_job.delayed_job",
-            default_params.merge(:params => ["argument"])
+      context "with a normal call" do
+        it "wraps it in a transaction" do
+          perform
+          transaction_data = last_transaction.to_h
+          expect(transaction_data).to include(
+            "action" => "TestClass#perform",
+            "namespace" => "background_job",
+            "error" => nil
+          )
+          expect(transaction_data["events"].map { |e| e["name"] })
+            .to eql(["perform_job.delayed_job"])
+          expect(transaction_data["sample_data"]).to include(
+            "metadata" => {
+              "priority" => 1,
+              "attempts" => 1,
+              "queue"    => "default",
+              "id"       => "123"
+            },
+            "params" => ["argument"]
           )
         end
 
@@ -89,14 +92,13 @@ describe Appsignal::Hooks::DelayedJobHook do
           end
 
           it "adds the more complex arguments" do
-            expect(Appsignal).to receive(:monitor_transaction).with(
-              "perform_job.delayed_job",
-              default_params.merge(
-                :params => {
-                  :foo => "Foo",
-                  :bar => "Bar"
-                }
-              )
+            perform
+            transaction_data = last_transaction.to_h
+            expect(transaction_data["sample_data"]).to include(
+              "params" => {
+                "foo" => "Foo",
+                "bar" => "Bar"
+              }
             )
           end
 
@@ -107,14 +109,13 @@ describe Appsignal::Hooks::DelayedJobHook do
             end
 
             it "filters selected arguments" do
-              expect(Appsignal).to receive(:monitor_transaction).with(
-                "perform_job.delayed_job",
-                default_params.merge(
-                  :params => {
-                    :foo => "[FILTERED]",
-                    :bar => "Bar"
-                  }
-                )
+              perform
+              transaction_data = last_transaction.to_h
+              expect(transaction_data["sample_data"]).to include(
+                "params" => {
+                  "foo" => "[FILTERED]",
+                  "bar" => "Bar"
+                }
               )
             end
           end
@@ -124,98 +125,135 @@ describe Appsignal::Hooks::DelayedJobHook do
           let(:run_at) { Time.parse("2017-01-01 10:01:00UTC") }
 
           it "reports queue_start with run_at time" do
+            # TODO: Not available in transaction.to_h yet.
+            # https://github.com/appsignal/appsignal-agent/issues/293
             expect(Appsignal).to receive(:monitor_transaction).with(
               "perform_job.delayed_job",
-              default_params.merge(:queue_start => run_at)
-            )
+              a_hash_including(:queue_start => run_at)
+            ).and_call_original
+            perform
           end
         end
 
-        context "with custom name call" do
+        context "with class method job" do
           let(:job_data) do
-            {
-              :payload_object => double(
-                :appsignal_name => "CustomClass#perform",
-                :args           => args
-              ),
-              :id         => "123",
-              :name       => "TestClass#perform",
-              :priority   => 1,
-              :attempts   => 1,
-              :queue      => "default",
-              :created_at => created_at,
-              :run_at     => run_at
-            }
-          end
-          let(:default_params) do
-            {
-              :class => "CustomClass",
-              :method => "perform",
-              :metadata => {
-                :priority => 1,
-                :attempts => 1,
-                :queue    => "default",
-                :id       => "123"
-              },
-              :queue_start => run_at
-            }
+            { :name => "CustomClassMethod.perform", :payload_object => payload_object }
           end
 
-          it "wraps it in a transaction with the correct params" do
-            expect(Appsignal).to receive(:monitor_transaction).with(
-              "perform_job.delayed_job",
-              default_params.merge(
-                :params => ["argument"]
-              )
-            )
+          it "wraps it in a transaction using the class method job name" do
+            perform
+            expect(last_transaction.to_h["action"]).to eql("CustomClassMethod.perform")
           end
+        end
 
-          context "with more complex params" do
-            let(:args) do
-              {
-                :foo => "Foo",
-                :bar => "Bar"
-              }
-            end
+        context "with custom name call" do
+          before { perform }
 
-            it "adds the more complex arguments" do
-              expect(Appsignal).to receive(:monitor_transaction).with(
-                "perform_job.delayed_job",
-                default_params.merge(
-                  :params => {
-                    :foo => "Foo",
-                    :bar => "Bar"
-                  }
-                )
-              )
+          context "with appsignal_name defined" do
+            context "with payload_object being an object" do
+              context "with value" do
+                let(:payload_object) { double(:appsignal_name => "CustomClass#perform") }
+
+                it "wraps it in a transaction using the custom name" do
+                  expect(last_transaction.to_h["action"]).to eql("CustomClass#perform")
+                end
+              end
+
+              context "with non-String value" do
+                let(:payload_object) { double(:appsignal_name => Object.new) }
+
+                it "wraps it in a transaction using the original job name" do
+                  expect(last_transaction.to_h["action"]).to eql("TestClass#perform")
+                end
+              end
+
+              context "with class method name as job" do
+                let(:payload_object) { double(:appsignal_name => "CustomClassMethod.perform") }
+
+                it "wraps it in a transaction using the custom name" do
+                  perform
+                  expect(last_transaction.to_h["action"]).to eql("CustomClassMethod.perform")
+                end
+              end
             end
 
-            context "with parameter filtering" do
-              before do
-                Appsignal.config = project_fixture_config("production")
-                Appsignal.config[:filter_parameters] = ["foo"]
+            context "with payload_object being a Hash" do
+              context "with value" do
+                let(:payload_object) { double(:appsignal_name => "CustomClassHash#perform") }
+
+                it "wraps it in a transaction using the custom name" do
+                  expect(last_transaction.to_h["action"]).to eql("CustomClassHash#perform")
+                end
               end
 
-              it "filters selected arguments" do
-                expect(Appsignal).to receive(:monitor_transaction).with(
-                  "perform_job.delayed_job",
-                  default_params.merge(
-                    :params => {
-                      :foo => "[FILTERED]",
-                      :bar => "Bar"
-                    }
-                  )
-                )
+              context "with non-String value" do
+                let(:payload_object) { double(:appsignal_name => Object.new) }
+
+                it "wraps it in a transaction using the original job name" do
+                  expect(last_transaction.to_h["action"]).to eql("TestClass#perform")
+                end
+              end
+
+              context "with class method name as job" do
+                let(:payload_object) { { :appsignal_name => "CustomClassMethod.perform" } }
+
+                it "wraps it in a transaction using the custom name" do
+                  perform
+                  expect(last_transaction.to_h["action"]).to eql("CustomClassMethod.perform")
+                end
+              end
+            end
+
+            context "with payload_object being acting like a Hash and returning a non-String value" do
+              class ClassActingAsHash
+                def self.[](_key)
+                  Object.new
+                end
+
+                def self.appsignal_name
+                  "ClassActingAsHash#perform"
+                end
+              end
+              let(:payload_object) { ClassActingAsHash }
+
+              # We check for hash values before object values
+              # this means ClassActingAsHash returns `Object.new` instead
+              # of `self.appsignal_name`. Since this isn't a valid `String`
+              # we return the default job name as action name.
+              it "wraps it in a transaction using the original job name" do
+                expect(last_transaction.to_h["action"]).to eql("TestClass#perform")
               end
             end
           end
         end
 
+        context "without job name" do
+          let(:job_data) do
+            { :name => "", :payload_object => payload_object }
+          end
+
+          it "wraps it in a transaction using the class method job name" do
+            perform
+            expect(last_transaction.to_h["action"]).to eql("unknown")
+          end
+        end
+
+        context "with invalid job name" do
+          let(:job_data) do
+            { :name => "Banana", :payload_object => payload_object }
+          end
+
+          it "wraps it in a transaction using the class method job name" do
+            perform
+            expect(last_transaction.to_h["action"]).to eql("unknown")
+          end
+        end
+
         if active_job_present?
           require "active_job"
 
           context "when wrapped by ActiveJob" do
-            let(:wrapped_job) do
+            let(:payload_object) do
               ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(
                 "arguments"  => args,
                 "job_class"  => "TestClass",
@@ -233,32 +271,30 @@ describe Appsignal::Hooks::DelayedJobHook do
                 :queue          => "default",
                 :created_at     => created_at,
                 :run_at         => run_at,
-                :payload_object => wrapped_job
+                :payload_object => payload_object
               )
             end
-            let(:default_params) do
-              {
-                :class    => "TestClass",
-                :method   => "perform",
-                :metadata => {
-                  :priority => 1,
-                  :attempts => 1,
-                  :queue    => "default",
-                  :id       => "123"
-                },
-                :queue_start => run_at,
-                :params      => args
-              }
-            end
             let(:args) { ["activejob_argument"] }
 
-            context "with simple params" do
-              it "wraps it in a transaction with the correct params" do
-                expect(Appsignal).to receive(:monitor_transaction).with(
-                  "perform_job.delayed_job",
-                  default_params.merge(:params => ["activejob_argument"])
-                )
-              end
+            it "wraps it in a transaction with the correct params" do
+              perform
+              transaction_data = last_transaction.to_h
+              expect(transaction_data).to include(
+                "action" => "TestClass#perform",
+                "namespace" => "background_job",
+                "error" => nil
+              )
+              expect(transaction_data["events"].map { |e| e["name"] })
+                .to eql(["perform_job.delayed_job"])
+              expect(transaction_data["sample_data"]).to include(
+                "metadata" => {
+                  "priority" => 1,
+                  "attempts" => 1,
+                  "queue"    => "default",
+                  "id"       => "123"
+                },
+                "params" => ["activejob_argument"]
+              )
             end
 
             context "with more complex params" do
@@ -270,14 +306,14 @@ describe Appsignal::Hooks::DelayedJobHook do
               end
 
               it "adds the more complex arguments" do
-                expect(Appsignal).to receive(:monitor_transaction).with(
-                  "perform_job.delayed_job",
-                  default_params.merge(
-                    :params => {
-                      :foo => "Foo",
-                      :bar => "Bar"
-                    }
-                  )
+                perform
+                transaction_data = last_transaction.to_h
+                expect(transaction_data).to include("action" => "TestClass#perform")
+                expect(transaction_data["sample_data"]).to include(
+                  "params" => {
+                    "foo" => "Foo",
+                    "bar" => "Bar"
+                  }
                 )
               end
 
@@ -288,14 +324,14 @@ describe Appsignal::Hooks::DelayedJobHook do
                 end
 
                 it "filters selected arguments" do
-                  expect(Appsignal).to receive(:monitor_transaction).with(
-                    "perform_job.delayed_job",
-                    default_params.merge(
-                      :params => {
-                        :foo => "[FILTERED]",
-                        :bar => "Bar"
-                      }
-                    )
+                  perform
+                  transaction_data = last_transaction.to_h
+                  expect(transaction_data).to include("action" => "TestClass#perform")
+                  expect(transaction_data["sample_data"]).to include(
+                    "params" => {
+                      "foo" => "[FILTERED]",
+                      "bar" => "Bar"
+                    }
                   )
                 end
               end
@@ -307,8 +343,9 @@ describe Appsignal::Hooks::DelayedJobHook do
               it "reports queue_start with run_at time" do
                 expect(Appsignal).to receive(:monitor_transaction).with(
                   "perform_job.delayed_job",
-                  default_params.merge(:queue_start => run_at)
-                )
+                  a_hash_including(:queue_start => run_at)
+                ).and_call_original
+                perform
               end
             end
           end
@@ -316,33 +353,28 @@ describe Appsignal::Hooks::DelayedJobHook do
       end
 
       context "with an erroring call" do
-        let(:error) { ExampleException }
-        let(:transaction) do
-          Appsignal::Transaction.new(
-            SecureRandom.uuid,
-            Appsignal::Transaction::BACKGROUND_JOB,
-            Appsignal::Transaction::GenericRequest.new({})
-          )
-        end
+        let(:error) { ExampleException.new("uh oh") }
         before do
           expect(invoked_block).to receive(:call).and_raise(error)
-
-          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-          expect(Appsignal::Transaction).to receive(:create)
-            .with(
-              kind_of(String),
-              Appsignal::Transaction::BACKGROUND_JOB,
-              kind_of(Appsignal::Transaction::GenericRequest)
-            ).and_return(transaction)
         end
 
         it "adds the error to the transaction" do
-          expect(transaction).to receive(:set_error).with(error)
-          expect(transaction).to receive(:complete)
-
           expect do
-            plugin.invoke_with_instrumentation(job, invoked_block)
+            perform
           end.to raise_error(error)
+
+          transaction_data = last_transaction.to_h
+          expect(transaction_data).to include(
+            "action" => "TestClass#perform",
+            "namespace" => "background_job",
+            "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)
+            }
+          )
         end
       end
     end