appsignal 2.11.1-java → 3.0.0.beta.1-java

data/lib/appsignal/minutely.rb

@@ -3,8 +3,6 @@
 module Appsignal
   class Minutely
     class ProbeCollection
-      include Appsignal::Utils::DeprecationMessage
-
       def initialize
         @probes = {}
       end
@@ -27,16 +25,6 @@ module Appsignal
         probes[key]
       end
 
-      # @param probe [Object] Any object that listens to the `call` method will
-      #   be used as a probe.
-      # @deprecated Use {#register} instead.
-      # @return [void]
-      def <<(probe)
-        deprecation_message "Deprecated `Appsignal::Minute.probes <<` " \
-          "call. Please use `Appsignal::Minutely.probes.register` instead."
-        register probe.object_id, probe
-      end
-
       # Register a new minutely probe.
       #
       # Supported probe types are:

data/lib/appsignal/system.rb

@@ -79,5 +79,9 @@ module Appsignal
     def self.jruby?
       RUBY_PLATFORM == "java"
     end
+
+    def self.ruby_2_7_or_newer?
+      RUBY_VERSION > "2.7"
+    end
   end
 end

data/lib/appsignal/transaction.rb

@@ -11,6 +11,7 @@ module Appsignal
     BLANK          = "".freeze
     ALLOWED_TAG_KEY_TYPES = [Symbol, String].freeze
     ALLOWED_TAG_VALUE_TYPES = [Symbol, String, Integer].freeze
+    BREADCRUMB_LIMIT = 20
 
     class << self
       def create(id, namespace, request, options = {})
@@ -58,7 +59,7 @@ module Appsignal
       end
     end
 
-    attr_reader :ext, :transaction_id, :action, :namespace, :request, :paused, :tags, :options, :discarded
+    attr_reader :ext, :transaction_id, :action, :namespace, :request, :paused, :tags, :options, :discarded, :breadcrumbs
 
     # @!attribute params
     #   Attribute for parameters of the transaction.
@@ -80,6 +81,7 @@ module Appsignal
       @paused = false
       @discarded = false
       @tags = {}
+      @breadcrumbs = []
       @store = Hash.new({})
       @options = options
       @options[:params_method] ||= :params
@@ -156,6 +158,31 @@ module Appsignal
       @tags.merge!(given_tags)
     end
 
+    # Add breadcrumbs to the transaction.
+    #
+    # @param category [String] category of breadcrumb
+    #   e.g. "UI", "Network", "Navigation", "Console".
+    # @param action [String] name of breadcrumb
+    #   e.g "The user clicked a button", "HTTP 500 from http://blablabla.com"
+    # @option message [String]  optional message in string format
+    # @option metadata [Hash<String,String>]  key/value metadata in <string, string> format
+    # @option time [Time] time of breadcrumb, should respond to `.to_i` defaults to `Time.now.utc`
+    # @return [void]
+    #
+    # @see Appsignal.add_breadcrumb
+    # @see http://docs.appsignal.com/ruby/instrumentation/breadcrumbs.html
+    #   Breadcrumb reference
+    def add_breadcrumb(category, action, message = "", metadata = {}, time = Time.now.utc)
+      @breadcrumbs.push(
+        :time => time.to_i,
+        :category => category,
+        :action => action,
+        :message => message,
+        :metadata => metadata
+      )
+      @breadcrumbs = @breadcrumbs.last(BREADCRUMB_LIMIT)
+    end
+
     # Set an action name for the transaction.
     #
     # An action name is used to identify the location of a certain sample;
@@ -287,7 +314,8 @@ module Appsignal
         :environment  => sanitized_environment,
         :session_data => sanitized_session_data,
         :metadata     => metadata,
-        :tags         => sanitized_tags
+        :tags         => sanitized_tags,
+        :breadcrumbs  => breadcrumbs
       }.each do |key, data|
         set_sample_data(key, data)
       end

data/lib/appsignal/version.rb

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

data/spec/lib/appsignal/auth_check_spec.rb

@@ -28,29 +28,6 @@ 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 }
 
@@ -62,7 +39,7 @@ describe Appsignal::AuthCheck do
       end
     end
 
-    context "when encountering an exception", :not_ruby19 do
+    context "when encountering an exception" do
       before { stubbed_request.to_timeout }
 
       it "raises an error" do

data/spec/lib/appsignal/cli_spec.rb

@@ -16,7 +16,7 @@ describe Appsignal::CLI do
 
       expect(output).to include "appsignal <command> [options]"
       expect(output).to include \
-        "Available commands: demo, diagnose, install, notify_of_deploy"
+        "Available commands: demo, diagnose, install"
     end
   end
 

data/spec/lib/appsignal/config_spec.rb

@@ -168,8 +168,6 @@ describe Appsignal::Config do
         :push_api_key                   => "abc",
         :name                           => "TestApp",
         :active                         => true,
-        :enable_frontend_error_catching => false,
-        :frontend_error_catching_path   => "/appsignal_error_catcher",
         :enable_allocation_tracking     => true,
         :enable_gc_instrumentation      => false,
         :enable_host_metrics            => true,
@@ -357,70 +355,6 @@ describe Appsignal::Config do
         config
       end
     end
-
-    describe "support for old config keys" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:config) { project_fixture_config(env, {}, test_logger(log)) }
-      let(:log) { StringIO.new }
-      before { capture_std_streams(std_stream, err_stream) { config } }
-
-      describe ":api_key" do
-        context "without :push_api_key" do
-          let(:env) { "old_config" }
-
-          it "sets the :push_api_key with the old :api_key value" do
-            expect(config[:push_api_key]).to eq "def"
-            expect(config.config_hash).to_not have_key :api_key
-
-            message = "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-
-        context "with :push_api_key" do
-          let(:env) { "old_config_mixed_with_new_config" }
-
-          it "ignores the :api_key config and deletes it" do
-            expect(config[:push_api_key]).to eq "ghi"
-            expect(config.config_hash).to_not have_key :api_key
-
-            message = "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-      end
-
-      describe ":ignore_exceptions" do
-        context "without :ignore_errors" do
-          let(:env) { "old_config" }
-
-          it "sets :ignore_errors with the old :ignore_exceptions value" do
-            expect(config[:ignore_errors]).to eq ["StandardError"]
-            expect(config.config_hash).to_not have_key :ignore_exceptions
-
-            message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-
-        context "with :ignore_errors" do
-          let(:env) { "old_config_mixed_with_new_config" }
-
-          it "ignores the :ignore_exceptions config" do
-            expect(config[:ignore_errors]).to eq ["NoMethodError"]
-            expect(config.config_hash).to_not have_key :ignore_exceptions
-
-            message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-      end
-    end
   end
 
   context "with config in the environment" do

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -114,43 +114,6 @@ describe Appsignal::EventFormatter do
         end
       end
     end
-
-    context "when registering deprecated formatters" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:deprecated_formatter) do
-        Class.new(Appsignal::EventFormatter) do
-          register "mock.deprecated"
-
-          def format(_payload)
-          end
-        end
-      end
-
-      it "registers deprecated formatters and logs & prints a warning" do
-        message = "Formatter for 'mock.deprecated' is using a deprecated registration method. " \
-          "This event formatter will not be loaded. " \
-          "Please update the formatter according to the documentation at: " \
-          "https://docs.appsignal.com/ruby/instrumentation/event-formatters.html"
-
-        logs = capture_logs do
-          capture_std_streams(std_stream, err_stream) { deprecated_formatter }
-        end
-        expect(logs).to contains_log :warn, message
-        expect(stderr).to include "appsignal WARNING: #{message}"
-
-        expect(klass.deprecated_formatter_classes.keys).to include("mock.deprecated")
-      end
-
-      it "initializes deprecated formatters" do
-        capture_std_streams(std_stream, err_stream) { deprecated_formatter }
-        klass.initialize_deprecated_formatters
-
-        expect(klass.registered?("mock.deprecated")).to be_truthy
-        expect(klass.formatters["mock.deprecated"]).to be_instance_of(deprecated_formatter)
-        expect(klass.deprecated_formatter_classes["mock.deprecated"]).to eq(deprecated_formatter)
-      end
-    end
   end
 
   describe ".registered?" do

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

@@ -3,6 +3,11 @@ describe Appsignal::Hooks::CelluloidHook do
     before :context do
       module Celluloid
         def self.shutdown
+          @shut_down = true
+        end
+
+        def self.shut_down?
+          @shut_down == true
         end
       end
       Appsignal::Hooks::CelluloidHook.new.install
@@ -18,7 +23,7 @@ describe Appsignal::Hooks::CelluloidHook do
     end
 
     specify { expect(Appsignal).to receive(:stop) }
-    specify { expect(Celluloid).to receive(:shutdown_without_appsignal) }
+    specify { expect(Celluloid.shut_down?).to be true }
 
     after do
       Celluloid.shutdown

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

@@ -20,8 +20,7 @@ describe Appsignal::Hooks::RakeHook do
       end
 
       it "calls the original task" do
-        expect(task).to receive(:execute_without_appsignal).with(arguments)
-        perform
+        expect(perform).to eq([])
       end
     end
 

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

@@ -1,33 +1,68 @@
 describe Appsignal::Hooks::RedisHook do
   before do
     Appsignal.config = project_fixture_config
-    Appsignal::Hooks.load_hooks
   end
 
   if DependencyHelper.redis_present?
     context "with redis" do
       context "with instrumentation enabled" do
-        before do
-          Appsignal.config.config_hash[:instrument_redis] = true
-          allow_any_instance_of(Redis::Client).to receive(:process_without_appsignal).and_return(1)
-        end
-
         describe "#dependencies_present?" do
           subject { described_class.new.dependencies_present? }
 
           it { is_expected.to be_truthy }
         end
 
-        it "should instrument a redis call" do
-          Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
-          expect(Appsignal::Transaction.current).to receive(:start_event)
-            .at_least(:once)
-          expect(Appsignal::Transaction.current).to receive(:finish_event)
-            .at_least(:once)
-            .with("query.redis", "redis://127.0.0.1:6379/0", "get ?", 0)
+        describe "integration" do
+          before do
+            Appsignal.config.config_hash[:instrument_redis] = true
+          end
+
+          context "install" do
+            before do
+              Appsignal::Hooks.load_hooks
+            end
+
+            it "does something" do
+              # Test if the last included module (prepended module) was our
+              # integration. That's not certain with the assertions below
+              # because we have to overwrite the `process` method for the test.
+              expect(Redis::Client.included_modules.first)
+                .to eql(Appsignal::Integrations::RedisIntegration)
+            end
+          end
+
+          context "instrumentation" do
+            before do
+              # Stub Redis::Client class so that it doesn't perform an actual
+              # Redis query. This class will be included (prepended) with the
+              # AppSignal Redis integration.
+              stub_const("Redis::Client", Class.new do
+                def id
+                  :stub_id
+                end
+
+                def process(_commands)
+                  :stub_process
+                end
+              end)
+              # Load the integration again for the stubbed Redis::Client class.
+              # Call it directly because {Appsignal::Hooks.load_hooks} keeps
+              # track if it was installed already or not.
+              Appsignal::Hooks::RedisHook.new.install
+            end
+
+            it "instrument a redis call" do
+              Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+              expect(Appsignal::Transaction.current).to receive(:start_event)
+                .at_least(:once)
+              expect(Appsignal::Transaction.current).to receive(:finish_event)
+                .at_least(:once)
+                .with("query.redis", :stub_id, "get ?", 0)
 
-          client = Redis::Client.new
-          expect(client.process([[:get, "key"]])).to eq 1
+              client = Redis::Client.new
+              expect(client.process([[:get, "key"]])).to eql(:stub_process)
+            end
+          end
         end
       end
 

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

@@ -60,7 +60,10 @@ describe Appsignal::Hooks::ResqueHook do
           "error" => nil,
           "namespace" => namespace,
           "metadata" => {},
-          "sample_data" => { "tags" => { "queue" => queue } }
+          "sample_data" => {
+            "breadcrumbs" => [],
+            "tags" => { "queue" => queue }
+          }
         )
         expect(transaction_hash["events"].map { |e| e["name"] })
           .to eql(["perform.resque"])
@@ -84,7 +87,10 @@ describe Appsignal::Hooks::ResqueHook do
             },
             "namespace" => namespace,
             "metadata" => {},
-            "sample_data" => { "tags" => { "queue" => queue } }
+            "sample_data" => {
+              "breadcrumbs" => [],
+              "tags" => { "queue" => queue }
+            }
           )
         end
       end
@@ -118,6 +124,7 @@ describe Appsignal::Hooks::ResqueHook do
             "metadata" => {},
             "sample_data" => {
               "tags" => { "queue" => queue },
+              "breadcrumbs" => [],
               "params" => [
                 "foo",
                 {
@@ -174,6 +181,7 @@ describe Appsignal::Hooks::ResqueHook do
             "namespace" => namespace,
             "metadata" => {},
             "sample_data" => {
+              "breadcrumbs" => [],
               "tags" => { "queue" => queue }
               # Params will be set by the ActiveJob integration
             }

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

@@ -1,55 +1,73 @@
 describe Appsignal::Hooks::ShoryukenMiddleware do
-  let(:current_transaction) { background_job_transaction }
-
   class DemoShoryukenWorker
   end
 
+  let(:time) { "2010-01-01 10:01:00UTC" }
   let(:worker_instance) { DemoShoryukenWorker.new }
-  let(:queue) { double }
-  let(:sqs_msg) { double(:attributes => {}) }
+  let(:queue) { "some-funky-queue-name" }
+  let(:sqs_msg) { double(:message_id => "msg1", :attributes => {}) }
   let(:body) { {} }
-
-  before do
-    allow(Appsignal::Transaction).to receive(:current).and_return(current_transaction)
-    start_agent
+  before(:context) { start_agent }
+  around { |example| keep_transactions { example.run } }
+
+  def perform_job(&block)
+    block ||= lambda {}
+    Timecop.freeze(Time.parse(time)) do
+      Appsignal::Hooks::ShoryukenMiddleware.new.call(
+        worker_instance,
+        queue,
+        sqs_msg,
+        body,
+        &block
+      )
+    end
   end
 
   context "with a performance call" do
-    let(:queue) { "some-funky-queue-name" }
+    let(:sent_timestamp) { Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 }
     let(:sqs_msg) do
-      double(:attributes => { "SentTimestamp" => Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 })
+      double(:message_id => "msg1", :attributes => { "SentTimestamp" => sent_timestamp })
     end
 
     context "with complex argument" do
-      let(:body) do
-        {
-          :foo => "Foo",
-          :bar => "Bar"
-        }
-      end
-      after do
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            # nothing
-          end
-        end
-      end
+      let(:body) { { :foo => "Foo", :bar => "Bar" } }
 
       it "wraps the job in a transaction with the correct params" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.shoryuken",
-          :class => "DemoShoryukenWorker",
-          :method => "perform",
-          :metadata => {
-            :queue => "some-funky-queue-name",
-            "SentTimestamp" => 217_123_200_000
-          },
-          :params => {
-            :foo => "Foo",
-            :bar => "Bar"
-          },
-          :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
+        allow_any_instance_of(Appsignal::Transaction).to receive(:set_queue_start).and_call_original
+        expect { perform_job }.to change { created_transactions.length }.by(1)
+
+        transaction = last_transaction
+        expect(transaction).to be_completed
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "action" => "DemoShoryukenWorker#perform",
+          "id" => kind_of(String), # AppSignal generated id
+          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+          "error" => nil
         )
+        expect(transaction_hash["events"].first).to include(
+          "allocation_count" => kind_of(Integer),
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "gc_duration" => kind_of(Float),
+          "start" => kind_of(Float),
+          "duration" => kind_of(Float),
+          "name" => "perform_job.shoryuken",
+          "title" => ""
+        )
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => { "foo" => "Foo", "bar" => "Bar" },
+          "metadata" => {
+            "message_id" => "msg1",
+            "queue" => queue,
+            "SentTimestamp" => sent_timestamp
+          }
+        )
+        expect(transaction).to have_received(:set_queue_start).with(sent_timestamp)
       end
 
       context "with parameter filtering" do
@@ -57,21 +75,16 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
           Appsignal.config = project_fixture_config("production")
           Appsignal.config[:filter_parameters] = ["foo"]
         end
+        after do
+          Appsignal.config[:filter_parameters] = []
+        end
 
         it "filters selected arguments" do
-          expect(Appsignal).to receive(:monitor_transaction).with(
-            "perform_job.shoryuken",
-            :class => "DemoShoryukenWorker",
-            :method => "perform",
-            :metadata => {
-              :queue => "some-funky-queue-name",
-              "SentTimestamp" => 217_123_200_000
-            },
-            :params => {
-              :foo => "[FILTERED]",
-              :bar => "Bar"
-            },
-            :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
+          perform_job
+
+          transaction_hash = last_transaction.to_h
+          expect(transaction_hash["sample_data"]).to include(
+            "params" => { "foo" => "[FILTERED]", "bar" => "Bar" }
           )
         end
       end
@@ -81,23 +94,12 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       let(:body) { "foo bar" }
 
       it "handles string arguments" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.shoryuken",
-          :class => "DemoShoryukenWorker",
-          :method => "perform",
-          :metadata => {
-            :queue => "some-funky-queue-name",
-            "SentTimestamp" => 217_123_200_000
-          },
-          :params => { :params => body },
-          :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
-        )
+        perform_job
 
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            # nothing
-          end
-        end
+        transaction_hash = last_transaction.to_h
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => { "params" => body }
+        )
       end
     end
 
@@ -105,58 +107,103 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       let(:body) { 1 }
 
       it "handles primitive types as arguments" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.shoryuken",
-          :class => "DemoShoryukenWorker",
-          :method => "perform",
-          :metadata => {
-            :queue => "some-funky-queue-name",
-            "SentTimestamp" => 217_123_200_000
-          },
-          :params => { :params => body },
-          :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
-        )
+        perform_job
 
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            # nothing
-          end
-        end
+        transaction_hash = last_transaction.to_h
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => { "params" => body }
+        )
       end
     end
   end
 
   context "with exception" do
-    let(:transaction) do
-      Appsignal::Transaction.new(
-        SecureRandom.uuid,
-        Appsignal::Transaction::BACKGROUND_JOB,
-        Appsignal::Transaction::GenericRequest.new({})
+    it "sets the exception on the transaction" do
+      expect do
+        expect do
+          perform_job { raise ExampleException, "error message" }
+        end.to raise_error(ExampleException)
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to be_completed
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "DemoShoryukenWorker#perform",
+        "id" => kind_of(String), # AppSignal generated id
+        "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+        "error" => {
+          "name" => "ExampleException",
+          "message" => "error message",
+          "backtrace" => kind_of(String)
+        }
       )
     end
+  end
 
-    before do
-      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)
+  context "with batched jobs" do
+    let(:sqs_msg) do
+      [
+        double(
+          :message_id => "msg2",
+          :attributes => { "SentTimestamp" => (Time.parse("1976-11-18 01:00:00UTC").to_i * 1000).to_s }
+        ),
+        double(
+          :message_id => "msg1",
+          :attributes => { "SentTimestamp" => sent_timestamp.to_s }
+        )
+      ]
     end
-
-    it "sets the exception on the transaction" do
-      expect(transaction).to receive(:set_error).with(ExampleException)
+    let(:body) do
+      [
+        "foo bar",
+        { :id => "123", :foo => "Foo", :bar => "Bar" }
+      ]
     end
+    let(:sent_timestamp) { Time.parse("1976-11-18 01:00:00UTC").to_i * 1000 }
 
-    after do
+    it "creates a transaction for the batch" do
+      allow_any_instance_of(Appsignal::Transaction).to receive(:set_queue_start).and_call_original
       expect do
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            raise ExampleException
-          end
-        end
-      end.to raise_error(ExampleException)
+        perform_job {}
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to be_completed
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "DemoShoryukenWorker#perform",
+        "id" => kind_of(String), # AppSignal generated id
+        "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+        "error" => nil
+      )
+      expect(transaction_hash["events"].first).to include(
+        "allocation_count" => kind_of(Integer),
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::DEFAULT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "gc_duration" => kind_of(Float),
+        "start" => kind_of(Float),
+        "duration" => kind_of(Float),
+        "name" => "perform_job.shoryuken",
+        "title" => ""
+      )
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => {
+          "msg2" => "foo bar",
+          "msg1" => { "id" => "123", "foo" => "Foo", "bar" => "Bar" }
+        },
+        "metadata" => {
+          "batch" => true,
+          "queue" => "some-funky-queue-name",
+          "SentTimestamp" => sent_timestamp.to_s # Earliest/oldest timestamp from messages
+        }
+      )
+      # Queue time based on earliest/oldest timestamp from messages
+      expect(transaction).to have_received(:set_queue_start).with(sent_timestamp)
     end
   end
 end