appsignal 3.13.0 → 4.0.0.beta.1

data/spec/lib/appsignal/transaction_spec.rb

@@ -1,8 +1,9 @@
 describe Appsignal::Transaction do
+  let(:options) { {} }
   let(:time) { Time.at(fixed_time) }
 
   before do
-    start_agent
+    start_agent(:options => options)
     Timecop.freeze(time)
   end
   after { Timecop.return }
@@ -32,86 +33,13 @@ describe Appsignal::Transaction do
         transaction = create_transaction
         expect(transaction).to eq current_transaction
       end
+    end
 
-      context "with legacy arguments" do
-        it "returns the created transaction" do
-          transaction_id = "mock-id"
-          namespace = "my_namespace"
-          transaction = legacy_create_transaction(
-            :id => transaction_id,
-            :namespace => namespace
-          )
-          expect(transaction).to be_a(Appsignal::Transaction)
-
-          expect(transaction).to have_id(transaction_id)
-          expect(transaction.transaction_id).to eq(transaction_id)
-
-          expect(transaction).to have_namespace(namespace)
-          expect(transaction.namespace).to eq(namespace)
-        end
-
-        it "logs deprecation warnings" do
-          logs =
-            capture_logs do
-              legacy_create_transaction(
-                :id => "mock-id",
-                :namespace => "my_namespace",
-                :request => Appsignal::Transaction::InternalGenericRequest.new({}),
-                :options => { :force => true }
-              )
-            end
-
-          expect(logs).to contains_log(
-            :warn,
-            "Appsignal::Transaction.create: " \
-              "A new Transaction is created using the transaction ID argument."
-          )
-          expect(logs).to contains_log(
-            :warn,
-            "Appsignal::Transaction.create: " \
-              "A Transaction is created using the namespace argument."
-          )
-          expect(logs).to contains_log(
-            :warn,
-            "Appsignal::Transaction.create: " \
-              "A Transaction is created using the request argument."
-          )
-          expect(logs).to contains_log(
-            :warn,
-            "Appsignal::Transaction.create: " \
-              "A Transaction is created using the `:force => true` option argument. "
-          )
-        end
-
-        it "prints deprecation warnings" do
-          err_stream = std_stream
-          capture_std_streams(std_stream, err_stream) do
-            legacy_create_transaction(
-              :id => "mock-id",
-              :namespace => "my_namespace",
-              :request => Appsignal::Transaction::InternalGenericRequest.new({}),
-              :options => { :force => true }
-            )
-          end
+    context "when an explicit extension transaction is passed in the initialiser" do
+      let(:ext) { "some_ext" }
 
-          stderr = err_stream.read
-          expect(stderr).to include(
-            "appsignal WARNING: Appsignal::Transaction.create: " \
-              "A new Transaction is created using the transaction ID argument."
-          )
-          expect(stderr).to include(
-            "appsignal WARNING: Appsignal::Transaction.create: " \
-              "A Transaction is created using the namespace argument."
-          )
-          expect(stderr).to include(
-            "appsignal WARNING: Appsignal::Transaction.create: " \
-              "A Transaction is created using the request argument."
-          )
-          expect(stderr).to include(
-            "appsignal WARNING: Appsignal::Transaction.create: " \
-              "A Transaction is created using the `:force => true` option argument. "
-          )
-        end
+      it "assigns the extension transaction to the transaction" do
+        expect(new_transaction(:ext => ext).ext).to be(ext)
       end
     end
 
@@ -137,28 +65,9 @@ describe Appsignal::Transaction do
         logs = capture_logs { create_transaction }
 
         expect(logs).to contains_log :warn,
-          "Trying to start new transaction with id 'transaction_id_2', but a " \
-            "transaction with id 'transaction_id_1' is already " \
-            "running. Using transaction 'transaction_id_1'."
-      end
-
-      context "with option :force => true" do
-        it "returns the newly created (and current) transaction" do
-          original_transaction = create_transaction
-
-          expect(original_transaction).to be_a(Appsignal::Transaction)
-          expect(current_transaction).to have_id("transaction_id_1")
-
-          new_transaction = legacy_create_transaction(
-            :id => "transaction_id_2",
-            :options => { :force => true }
-          )
-
-          expect(new_transaction).to be_a(Appsignal::Transaction)
-          expect(new_transaction).to_not eq(original_transaction)
-          expect(new_transaction).to have_id("transaction_id_2")
-          expect(current_transaction).to eq(new_transaction)
-        end
+          "Trying to start new transaction, but a transaction with id " \
+            "'transaction_id_1' is already running. " \
+            "Using transaction 'transaction_id_1'."
       end
     end
   end
@@ -252,7 +161,7 @@ describe Appsignal::Transaction do
 
     context "when transaction is being sampled" do
       it "samples data" do
-        transaction.set_tags(:foo => "bar")
+        transaction.add_tags(:foo => "bar")
         keep_transactions { transaction.complete }
         expect(transaction).to include_tags("foo" => "bar")
       end
@@ -299,6 +208,306 @@ describe Appsignal::Transaction do
         end
       end
     end
+
+    context "when a transaction has errors" do
+      let(:error) do
+        e = ExampleStandardError.new("test message")
+        allow(e).to receive(:backtrace).and_return(["line 1"])
+        e
+      end
+
+      let(:other_error) do
+        e = ExampleStandardError.new("other test message")
+        allow(e).to receive(:backtrace).and_return(["line 2"])
+        e
+      end
+
+      context "when an error is already set on the transaction" do
+        it "reports errors as duplicate transactions" do
+          transaction.set_error(error)
+          transaction.add_error(other_error)
+
+          expect do
+            transaction.complete
+          end.to change { created_transactions.count }.from(1).to(2)
+
+          original_transaction, duplicate_transaction = created_transactions
+
+          expect(original_transaction).to have_error(
+            "ExampleStandardError",
+            "test message",
+            ["line 1"]
+          )
+          expect(original_transaction).to be_completed
+
+          expect(duplicate_transaction).to have_error(
+            "ExampleStandardError",
+            "other test message",
+            ["line 2"]
+          )
+          expect(duplicate_transaction).to be_completed
+        end
+      end
+
+      context "when no error is set on the transaction" do
+        it "reports the first error in the original transaction" do
+          transaction.add_error(error)
+          transaction.add_error(other_error)
+
+          expect do
+            transaction.complete
+          end.to change { created_transactions.count }.from(1).to(2)
+
+          original_transaction, duplicate_transaction = created_transactions
+
+          expect(original_transaction).to have_error(
+            "ExampleStandardError",
+            "test message",
+            ["line 1"]
+          )
+          expect(original_transaction).to be_completed
+
+          expect(duplicate_transaction).to have_error(
+            "ExampleStandardError",
+            "other test message",
+            ["line 2"]
+          )
+          expect(duplicate_transaction).to be_completed
+        end
+      end
+
+      it "stores the last reported errors" do
+        transaction.add_error(error)
+        transaction.add_error(other_error)
+        transaction.complete
+
+        expect(Appsignal::Transaction.last_errors).to contain_exactly(error, other_error)
+      end
+
+      describe "metadata" do
+        let(:tags) { { "tag" => "value" } }
+        let(:params) { { "param" => "value" } }
+        let(:headers) { { "REQUEST_METHOD" => "value" } }
+        let(:session_data) { { "session_data" => "value" } }
+        let(:custom_data) { { "custom_data" => "value" } }
+        before do
+          transaction.set_namespace("My namespace")
+          transaction.set_action("My action")
+          transaction.set_metadata("path", "/some/path")
+          transaction.set_metadata("method", "GET")
+          transaction.add_tags(tags)
+          transaction.add_params(params)
+          transaction.add_headers(headers)
+          transaction.add_session_data(session_data)
+          transaction.add_custom_data(custom_data)
+          transaction.add_breadcrumb("category", "action", "message", { "meta" => "data" })
+
+          transaction.start_event
+          transaction.finish_event("name", "title", "body", 1)
+
+          transaction.add_error(error)
+          transaction.add_error(other_error)
+
+          transaction.complete
+        end
+
+        it "copies the transaction metadata and sample data on the duplicate transaction" do
+          original_transaction, duplicate_transaction = created_transactions
+
+          duplicate_hash = duplicate_transaction.to_h.tap do |h|
+            h.delete("id")
+            h.delete("error")
+          end
+          original_hash = original_transaction.to_h.tap do |h|
+            h.delete("id")
+            h.delete("error")
+          end
+          expect(duplicate_hash).to eq(original_hash)
+        end
+
+        it "the duplicate transaction has a different transaction id" do
+          original_transaction, duplicate_transaction = created_transactions
+
+          expect(original_transaction.transaction_id)
+            .to_not eq(duplicate_transaction.transaction_id)
+        end
+
+        it "the duplicate transaction has a different extension transaction than the original" do
+          original_transaction, duplicate_transaction = created_transactions
+
+          expect(original_transaction.ext).to_not eq(duplicate_transaction.ext)
+        end
+
+        it "sets is_duplicate set to true on the duplicate transaction" do
+          original_transaction, duplicate_transaction = created_transactions
+
+          expect(original_transaction.is_duplicate).to be(false)
+          expect(duplicate_transaction.is_duplicate).to be(true)
+        end
+      end
+
+      it "merges sample data from the original transaction in the duplicate transaction" do
+        transaction.add_tags("root" => "tag")
+        transaction.add_params("root" => "param")
+        transaction.add_session_data("root" => "session")
+        transaction.add_headers("REQUEST_METHOD" => "root")
+        transaction.add_custom_data("root" => "custom")
+        transaction.add_breadcrumb("root", "breadcrumb")
+        Appsignal.report_error(error) do |t|
+          t.add_tags("original" => "tag")
+          t.add_params("original" => "param")
+          t.add_session_data("original" => "session")
+          t.add_headers("REQUEST_PATH" => "/original")
+          t.add_custom_data("original" => "custom")
+          t.add_breadcrumb("original", "breadcrumb")
+        end
+        Appsignal.report_error(other_error) do |t|
+          t.add_tags("duplicate" => "tag")
+          t.add_params("duplicate" => "param")
+          t.add_session_data("duplicate" => "session")
+          t.add_headers("HTTP_ACCEPT" => "duplicate")
+          t.add_custom_data("duplicate" => "custom")
+          t.add_breadcrumb("duplicate", "breadcrumb")
+        end
+        transaction.add_tags("root2" => "tag")
+        transaction.add_params("root2" => "param")
+        transaction.add_session_data("root2" => "session")
+        transaction.add_headers("PATH_INFO" => "/root2")
+        transaction.add_custom_data("root2" => "custom")
+        transaction.add_breadcrumb("root2", "breadcrumb")
+        transaction.complete
+
+        original_transaction, duplicate_transaction = created_transactions
+        # Original
+        expect(original_transaction).to include_tags(
+          "root" => "tag",
+          "original" => "tag",
+          "root2" => "tag"
+        )
+        expect(original_transaction).to_not include_tags("duplicate" => anything)
+        expect(original_transaction).to include_params(
+          "root" => "param",
+          "original" => "param",
+          "root2" => "param"
+        )
+        expect(original_transaction).to_not include_params("duplicate" => anything)
+        expect(original_transaction).to include_session_data(
+          "root" => "session",
+          "original" => "session",
+          "root2" => "session"
+        )
+        expect(original_transaction).to_not include_session_data("duplicate" => anything)
+        expect(original_transaction).to include_environment(
+          "REQUEST_METHOD" => "root",
+          "REQUEST_PATH" => "/original",
+          "PATH_INFO" => "/root2"
+        )
+        expect(original_transaction).to_not include_environment("HTTP_ACCEPT" => anything)
+        expect(original_transaction).to include_custom_data(
+          "root" => "custom",
+          "original" => "custom",
+          "root2" => "custom"
+        )
+        expect(original_transaction).to_not include_custom_data("duplicate" => anything)
+        expect(original_transaction).to include_breadcrumb("breadcrumb", "root")
+        expect(original_transaction).to include_breadcrumb("breadcrumb", "original")
+        expect(original_transaction).to include_breadcrumb("breadcrumb", "root2")
+        expect(original_transaction).to_not include_breadcrumb("breadcrumb", "duplicate")
+
+        # Duplicate
+        expect(duplicate_transaction).to include_tags(
+          "root" => "tag",
+          "duplicate" => "tag",
+          "root2" => "tag"
+        )
+        expect(duplicate_transaction).to_not include_tags("original" => anything)
+        expect(duplicate_transaction).to include_params(
+          "root" => "param",
+          "duplicate" => "param",
+          "root2" => "param"
+        )
+        expect(duplicate_transaction).to_not include_params("original" => anything)
+        expect(duplicate_transaction).to include_session_data(
+          "root" => "session",
+          "duplicate" => "session",
+          "root2" => "session"
+        )
+        expect(duplicate_transaction).to_not include_session_data("original" => anything)
+        expect(duplicate_transaction).to include_environment(
+          "PATH_INFO" => "/root2",
+          "HTTP_ACCEPT" => "duplicate",
+          "REQUEST_METHOD" => "root"
+        )
+        expect(duplicate_transaction).to_not include_environment("REQUEST_PATH" => anything)
+        expect(duplicate_transaction).to include_custom_data(
+          "root" => "custom",
+          "duplicate" => "custom",
+          "root2" => "custom"
+        )
+        expect(duplicate_transaction).to_not include_custom_data("original" => anything)
+        expect(duplicate_transaction).to include_breadcrumb("breadcrumb", "root")
+        expect(duplicate_transaction).to include_breadcrumb("breadcrumb", "duplicate")
+        expect(duplicate_transaction).to include_breadcrumb("breadcrumb", "root2")
+        expect(duplicate_transaction).to_not include_breadcrumb("breadcrumb", "original")
+      end
+
+      it "overrides sample data from the original transaction in the duplicate transaction" do
+        transaction.add_tags("changeme" => "tag")
+        transaction.add_params("changeme" => "param")
+        transaction.add_session_data("changeme" => "session")
+        transaction.add_headers("REQUEST_METHOD" => "root")
+        transaction.add_custom_data("changeme" => "custom")
+        Appsignal.report_error(error)
+        Appsignal.report_error(other_error) do |t|
+          t.add_tags("changeme" => "duplicate_tag")
+          t.add_params("changeme" => "duplicate_param")
+          t.add_session_data("changeme" => "duplicate_session")
+          t.add_headers("REQUEST_METHOD" => "duplicate")
+          t.add_custom_data("changeme" => "duplicate_custom")
+        end
+        transaction.add_tags("changeme" => "changed_tag")
+        transaction.add_params("changeme" => "changed_param")
+        transaction.add_session_data("changeme" => "changed_session")
+        transaction.add_headers("REQUEST_METHOD" => "changed")
+        transaction.add_custom_data("changeme" => "changed_custom")
+        transaction.complete
+
+        original_transaction, duplicate_transaction = created_transactions
+        # Original
+        expect(original_transaction).to include_tags(
+          "changeme" => "changed_tag"
+        )
+        expect(original_transaction).to include_params(
+          "changeme" => "changed_param"
+        )
+        expect(original_transaction).to include_session_data(
+          "changeme" => "changed_session"
+        )
+        expect(original_transaction).to include_environment(
+          "REQUEST_METHOD" => "changed"
+        )
+        expect(original_transaction).to include_custom_data(
+          "changeme" => "changed_custom"
+        )
+
+        # Duplicate
+        expect(duplicate_transaction).to include_tags(
+          "changeme" => "duplicate_tag"
+        )
+        expect(duplicate_transaction).to include_params(
+          "changeme" => "duplicate_param"
+        )
+        expect(duplicate_transaction).to include_session_data(
+          "changeme" => "duplicate_session"
+        )
+        expect(duplicate_transaction).to include_environment(
+          "REQUEST_METHOD" => "duplicate"
+        )
+        expect(duplicate_transaction).to include_custom_data(
+          "changeme" => "duplicate_custom"
+        )
+      end
+    end
   end
 
   context "pausing" do
@@ -363,49 +572,9 @@ describe Appsignal::Transaction do
       end
     end
 
-    context "transaction id" do
-      before do
-        allow(SecureRandom).to receive(:uuid).and_return("mock_transaction_id")
-      end
-
-      it "sets the transaction id" do
-        expect(transaction).to have_id("mock_transaction_id")
-      end
-    end
-
     it "sets the namespace to http_request" do
       expect(transaction.namespace).to eq "http_request"
     end
-
-    it "sets the request" do
-      expect(transaction.request).to be_a(Appsignal::Transaction::InternalGenericRequest)
-    end
-
-    it "sets the request not to paused" do
-      expect(transaction.paused?).to be_falsy
-    end
-
-    it "sets no tags by default" do
-      expect(transaction.tags).to be_empty
-    end
-
-    describe "#options" do
-      let(:options) { transaction.options }
-
-      it "sets the default :params_method" do
-        expect(options[:params_method]).to eq :params
-      end
-
-      context "with overridden options" do
-        let(:transaction) do
-          legacy_new_transaction(:options => { :params_method => :filtered_params })
-        end
-
-        it "sets the overridden :params_method" do
-          expect(options[:params_method]).to eq :filtered_params
-        end
-      end
-    end
   end
 
   describe "#store" do
@@ -423,174 +592,122 @@ describe Appsignal::Transaction do
     end
   end
 
-  describe "#params" do
+  describe "#add_params" do
     let(:transaction) { new_transaction }
-    let(:params) { transaction.params }
-
-    context "with custom params set on transaction" do
-      before { transaction.set_params(:foo => "bar") }
-
-      it "returns custom parameters" do
-        expect(params).to eq(:foo => "bar")
-      end
-
-      context "when params is a callable object" do
-        it "calls the params object and sets the return value as parametesr" do
-          transaction.set_params { { "param1" => "value1" } }
-
-          expect(params).to eq("param1" => "value1")
-        end
-      end
-    end
-
-    context "without custom params set on transaction" do
-      let(:transaction) do
-        legacy_new_transaction(
-          :request => legacy_request(
-            :params => {
-              "action" => "show",
-              "controller" => "blog_posts",
-              "id" => "1"
-
-            }
-          )
-        )
-      end
 
-      it "returns parameters from request" do
-        expect(params).to eq(
-          "action" => "show",
-          "controller" => "blog_posts",
-          "id" => "1"
-        )
-      end
+    it "has a #set_params alias" do
+      expect(transaction.method(:add_params)).to eq(transaction.method(:set_params))
     end
-  end
 
-  describe "#params=" do
-    let(:transaction) { new_transaction }
-
-    it "sets params on the transaction" do
-      params = { "foo" => "bar" }
-      silence { transaction.params = params }
+    it "adds the params to the transaction" do
+      params = { "key" => "value" }
+      transaction.add_params(params)
 
       transaction._sample
-      expect(transaction.params).to eq(params)
       expect(transaction).to include_params(params)
     end
 
-    it "logs a deprecation warning" do
-      logs =
-        capture_logs do
-          transaction.params = { "foo" => "bar" }
-        end
+    it "merges the params on the transaction" do
+      transaction.add_params("abc" => "value")
+      transaction.add_params("def" => "value")
+      transaction.add_params { { "xyz" => "value" } }
 
-      expect(logs).to contains_log(
-        :warn,
-        "Transaction#params= is deprecated." \
-          "Use Transaction#set_params or #set_params_if_nil instead."
+      transaction._sample
+      expect(transaction).to include_params(
+        "abc" => "value",
+        "def" => "value",
+        "xyz" => "value"
       )
     end
-  end
-
-  describe "#set_params" do
-    let(:transaction) { new_transaction }
 
-    context "when the params are set" do
-      it "updates the params on the transaction" do
-        params = { "key" => "value" }
-        transaction.set_params(params)
+    it "adds the params to the transaction with a block" do
+      params = { "key" => "value" }
+      transaction.add_params { params }
 
-        transaction._sample
-        expect(transaction.params).to eq(params)
-        expect(transaction).to include_params(params)
-      end
+      transaction._sample
+      expect(transaction).to include_params(params)
+    end
 
-      it "updates the params on the transaction with a block" do
-        params = { "key" => "value" }
-        transaction.set_params { params }
+    it "adds the params block value when both an argument and block are given" do
+      arg_params = { "argument" => "value" }
+      block_params = { "block" => "value" }
+      transaction.add_params(arg_params) { block_params }
 
-        transaction._sample
-        expect(transaction.params).to eq(params)
-        expect(transaction).to include_params(params)
-      end
+      transaction._sample
+      expect(transaction).to include_params(block_params)
+    end
 
-      it "updates with the params argument when both an argument and block are given" do
-        arg_params = { "argument" => "value" }
-        block_params = { "block" => "value" }
-        transaction.set_params(arg_params) { block_params }
+    it "logs an error if an error occurred storing the params" do
+      transaction.add_params { raise "uh oh" }
 
-        transaction._sample
-        expect(transaction.params).to eq(arg_params)
-        expect(transaction).to include_params(arg_params)
-      end
+      logs = capture_logs { transaction._sample }
+      expect(logs).to contains_log(
+        :error,
+        "Exception while fetching params: RuntimeError: uh oh"
+      )
+    end
 
-      it "logs an error if an error occurred storing the params" do
-        transaction.set_params { raise "uh oh" }
+    it "does not update the params on the transaction if the given value is nil" do
+      params = { "key" => "value" }
+      transaction.add_params(params)
+      transaction.add_params(nil)
 
-        logs = capture_logs { transaction._sample }
-        expect(logs).to contains_log(
-          :error,
-          "Exception while fetching params: RuntimeError: uh oh"
-        )
-      end
+      transaction._sample
+      expect(transaction).to include_params(params)
     end
 
-    context "when the given params is nil" do
-      it "does not update the params on the transaction" do
-        params = { "key" => "value" }
-        transaction.set_params(params)
-        transaction.set_params(nil)
+    context "with AppSignal filtering" do
+      let(:options) { { :filter_parameters => %w[foo] } }
+
+      it "returns sanitized custom params" do
+        transaction.add_params("foo" => "value", "baz" => "bat")
 
         transaction._sample
-        expect(transaction.params).to eq(params)
-        expect(transaction).to include_params(params)
+        expect(transaction).to include_params("foo" => "[FILTERED]", "baz" => "bat")
       end
     end
   end
 
-  describe "#set_params_if_nil" do
+  describe "#add_params_if_nil" do
     let(:transaction) { new_transaction }
 
+    it "has a #set_params_if_nil alias" do
+      expect(transaction.method(:add_params_if_nil)).to eq(transaction.method(:set_params_if_nil))
+    end
+
     context "when the params are not set" do
-      it "sets the params on the transaction" do
+      it "adds the params to the transaction" do
         params = { "key" => "value" }
-        transaction.set_params_if_nil(params)
+        transaction.add_params_if_nil(params)
 
         transaction._sample
-        expect(transaction.params).to eq(params)
         expect(transaction).to include_params(params)
       end
 
-      it "updates the params on the transaction with a block" do
+      it "adds the params to the transaction with a block" do
         params = { "key" => "value" }
-        transaction.set_params_if_nil { params }
+        transaction.add_params_if_nil { params }
 
         transaction._sample
-        expect(transaction.params).to eq(params)
         expect(transaction).to include_params(params)
       end
 
-      it "updates with the params argument when both an argument and block are given" do
+      it "adds the params block value when both an argument and block are given" do
         arg_params = { "argument" => "value" }
         block_params = { "block" => "value" }
-        transaction.set_params_if_nil(arg_params) { block_params }
+        transaction.add_params_if_nil(arg_params) { block_params }
 
         transaction._sample
-        expect(transaction.params).to eq(arg_params)
-        expect(transaction).to include_params(arg_params)
+        expect(transaction).to include_params(block_params)
       end
 
-      context "when the given params is nil" do
-        it "does not update the params on the transaction" do
-          params = { "key" => "value" }
-          transaction.set_params(params)
-          transaction.set_params_if_nil(nil)
+      it "does not update the params on the transaction if the given value is nil" do
+        params = { "key" => "value" }
+        transaction.add_params(params)
+        transaction.add_params_if_nil(nil)
 
-          transaction._sample
-          expect(transaction.params).to eq(params)
-          expect(transaction).to include_params(params)
-        end
+        transaction._sample
+        expect(transaction).to include_params(params)
       end
     end
 
@@ -598,144 +715,156 @@ describe Appsignal::Transaction do
       it "does not update the params on the transaction" do
         preset_params = { "other" => "params" }
         params = { "key" => "value" }
-        transaction.set_params(preset_params)
-        transaction.set_params_if_nil(params)
+        transaction.add_params(preset_params)
+        transaction.add_params_if_nil(params)
 
         transaction._sample
-        expect(transaction.params).to eq(preset_params)
         expect(transaction).to include_params(preset_params)
       end
 
       it "does not update the params with a block on the transaction" do
         preset_params = { "other" => "params" }
         params = { "key" => "value" }
-        transaction.set_params(preset_params)
-        transaction.set_params_if_nil { params }
+        transaction.add_params(preset_params)
+        transaction.add_params_if_nil { params }
 
         transaction._sample
-        expect(transaction.params).to eq(preset_params)
         expect(transaction).to include_params(preset_params)
       end
     end
   end
 
-  describe "#set_session_data" do
+  describe "#add_session_data" do
     let(:transaction) { new_transaction }
 
-    context "when the session data is set" do
-      it "updates the session data on the transaction" do
-        data = { "key" => "value" }
-        transaction.set_session_data(data)
+    it "has a #set_session_data alias" do
+      expect(transaction.method(:add_session_data)).to eq(transaction.method(:set_session_data))
+    end
 
-        transaction._sample
-        expect(transaction).to include_session_data(data)
-      end
+    it "adds the session data to the transaction" do
+      data = { "key" => "value" }
+      transaction.add_session_data(data)
 
-      it "updates the session data on the transaction with a block" do
-        data = { "key" => "value" }
-        transaction.set_session_data { data }
+      transaction._sample
+      expect(transaction).to include_session_data(data)
+    end
 
-        transaction._sample
-        expect(transaction).to include_session_data(data)
-      end
+    it "merges the session data on the transaction" do
+      transaction.add_session_data("abc" => "value")
+      transaction.add_session_data("def" => "value")
+      transaction.add_session_data { { "xyz" => "value" } }
 
-      it "updates with the session data argument when both an argument and block are given" do
-        arg_data = { "argument" => "value" }
-        block_data = { "block" => "value" }
-        transaction.set_session_data(arg_data) { block_data }
+      transaction._sample
+      expect(transaction).to include_session_data(
+        "abc" => "value",
+        "def" => "value",
+        "xyz" => "value"
+      )
+    end
 
-        transaction._sample
-        expect(transaction).to include_session_data(arg_data)
-      end
+    it "adds the session data to the transaction with a block" do
+      data = { "key" => "value" }
+      transaction.add_session_data { data }
 
-      it "does not include filtered out session data" do
-        Appsignal.config[:filter_session_data] = ["filtered_key"]
-        transaction.set_session_data("data" => "value1", "filtered_key" => "filtered_value")
+      transaction._sample
+      expect(transaction).to include_session_data(data)
+    end
 
-        transaction._sample
-        expect(transaction).to include_session_data("data" => "value1")
-      end
+    it "adds the session data block value when both an argument and block are given" do
+      arg_data = { "argument" => "value" }
+      block_data = { "block" => "value" }
+      transaction.add_session_data(arg_data) { block_data }
 
-      it "logs an error if an error occurred storing the session data" do
-        transaction.set_session_data { raise "uh oh" }
+      transaction._sample
+      expect(transaction).to include_session_data(block_data)
+    end
 
-        logs = capture_logs { transaction._sample }
-        expect(logs).to contains_log(
-          :error,
-          "Exception while fetching session data: RuntimeError: uh oh"
-        )
-      end
+    it "logs an error if an error occurred storing the session data" do
+      transaction.add_session_data { raise "uh oh" }
+
+      logs = capture_logs { transaction._sample }
+      expect(logs).to contains_log(
+        :error,
+        "Exception while fetching session data: RuntimeError: uh oh"
+      )
     end
 
-    context "when the given session data is nil" do
-      it "does not update the session data on the transaction" do
-        data = { "key" => "value" }
-        transaction.set_session_data(data)
-        transaction.set_session_data(nil)
+    it "does not update the session data on the transaction if the given value is nil" do
+      data = { "key" => "value" }
+      transaction.add_session_data(data)
+      transaction.add_session_data(nil)
+
+      transaction._sample
+      expect(transaction).to include_session_data(data)
+    end
+
+    context "with filter_session_data" do
+      let(:options) { { :filter_session_data => ["filtered_key"] } }
+
+      it "does not include filtered out session data" do
+        transaction.add_session_data("data" => "value1", "filtered_key" => "filtered_value")
 
         transaction._sample
-        expect(transaction).to include_session_data(data)
+        expect(transaction).to include_session_data("data" => "value1")
       end
     end
   end
 
-  describe "#set_session_data_if_nil" do
+  describe "#add_session_data_if_nil" do
     let(:transaction) { new_transaction }
 
-    context "when the params are not set" do
-      it "sets the params on the transaction" do
+    context "when the session data is not set" do
+      it "sets the session data on the transaction" do
         data = { "key" => "value" }
-        transaction.set_session_data_if_nil(data)
+        transaction.add_session_data_if_nil(data)
 
         transaction._sample
         expect(transaction).to include_session_data(data)
       end
 
-      it "updates the params on the transaction with a block" do
+      it "updates the session data on the transaction with a block" do
         data = { "key" => "value" }
-        transaction.set_session_data_if_nil { data }
+        transaction.add_session_data_if_nil { data }
 
         transaction._sample
         expect(transaction).to include_session_data(data)
       end
 
-      it "updates with the params argument when both an argument and block are given" do
+      it "updates with the session data block when both an argument and block are given" do
         arg_data = { "argument" => "value" }
         block_data = { "block" => "value" }
-        transaction.set_session_data_if_nil(arg_data) { block_data }
+        transaction.add_session_data_if_nil(arg_data) { block_data }
 
         transaction._sample
-        expect(transaction).to include_session_data(arg_data)
+        expect(transaction).to include_session_data(block_data)
       end
 
-      context "when the given params is nil" do
-        it "does not update the params on the transaction" do
-          data = { "key" => "value" }
-          transaction.set_session_data(data)
-          transaction.set_session_data_if_nil(nil)
+      it "does not update the session data on the transaction if the given value is nil" do
+        data = { "key" => "value" }
+        transaction.add_session_data(data)
+        transaction.add_session_data_if_nil(nil)
 
-          transaction._sample
-          expect(transaction).to include_session_data(data)
-        end
+        transaction._sample
+        expect(transaction).to include_session_data(data)
       end
     end
 
-    context "when the params are set" do
-      it "does not update the params on the transaction" do
+    context "when the session data are set" do
+      it "does not update the session data on the transaction" do
         preset_data = { "other" => "data" }
         data = { "key" => "value" }
-        transaction.set_session_data(preset_data)
-        transaction.set_session_data_if_nil(data)
+        transaction.add_session_data(preset_data)
+        transaction.add_session_data_if_nil(data)
 
         transaction._sample
         expect(transaction).to include_session_data(preset_data)
       end
 
-      it "does not update the params with a block on the transaction" do
+      it "does not update the session data with a block on the transaction" do
         preset_data = { "other" => "data" }
         data = { "key" => "value" }
-        transaction.set_session_data(preset_data)
-        transaction.set_session_data_if_nil { data }
+        transaction.add_session_data(preset_data)
+        transaction.add_session_data_if_nil { data }
 
         transaction._sample
         expect(transaction).to include_session_data(preset_data)
@@ -743,123 +872,141 @@ describe Appsignal::Transaction do
     end
   end
 
-  describe "#set_headers" do
+  describe "#add_headers" do
     let(:transaction) { new_transaction }
 
-    context "when the headers are set" do
-      it "updates the headers on the transaction" do
-        headers = { "PATH_INFO" => "value" }
-        transaction.set_headers(headers)
+    it "has a #set_headers alias" do
+      expect(transaction.method(:add_headers)).to eq(transaction.method(:set_headers))
+    end
 
-        transaction._sample
-        expect(transaction).to include_environment(headers)
-      end
+    it "adds the headers to the transaction" do
+      headers = { "PATH_INFO" => "value" }
+      transaction.add_headers(headers)
 
-      it "updates the headers on the transaction with a block" do
-        headers = { "PATH_INFO" => "value" }
-        transaction.set_headers { headers }
+      transaction._sample
+      expect(transaction).to include_environment(headers)
+    end
 
-        transaction._sample
-        expect(transaction).to include_environment(headers)
-      end
+    it "merges the headers on the transaction" do
+      transaction.add_headers("PATH_INFO" => "value")
+      transaction.add_headers("REQUEST_METHOD" => "value")
+      transaction.add_headers { { "HTTP_ACCEPT" => "value" } }
 
-      it "updates with the headers argument when both an argument and block are given" do
-        arg_data = { "PATH_INFO" => "/arg-path" }
-        block_data = { "PATH_INFO" => "/block-path" }
-        transaction.set_headers(arg_data) { block_data }
+      transaction._sample
+      expect(transaction).to include_environment(
+        "PATH_INFO" => "value",
+        "REQUEST_METHOD" => "value",
+        "HTTP_ACCEPT" => "value"
+      )
+    end
 
-        transaction._sample
-        expect(transaction).to include_environment(arg_data)
-      end
+    it "adds the headers to the transaction with a block" do
+      headers = { "PATH_INFO" => "value" }
+      transaction.add_headers { headers }
 
-      it "does not include filtered out headers" do
-        Appsignal.config[:request_headers] = ["MY_HEADER"]
-        transaction.set_headers("MY_HEADER" => "value1", "filtered_key" => "filtered_value")
+      transaction._sample
+      expect(transaction).to include_environment(headers)
+    end
 
-        transaction._sample
-        expect(transaction).to include_environment("MY_HEADER" => "value1")
-      end
+    it "adds the headers block value when both an argument and block are given" do
+      arg_data = { "PATH_INFO" => "/arg-path" }
+      block_data = { "PATH_INFO" => "/block-path" }
+      transaction.add_headers(arg_data) { block_data }
+
+      transaction._sample
+      expect(transaction).to include_environment(block_data)
+    end
 
-      it "logs an error if an error occurred storing the headers" do
-        transaction.set_headers { raise "uh oh" }
+    it "logs an error if an error occurred storing the headers" do
+      transaction.add_headers { raise "uh oh" }
 
-        logs = capture_logs { transaction._sample }
-        expect(logs).to contains_log(
-          :error,
-          "Exception while fetching headers: RuntimeError: uh oh"
-        )
-      end
+      logs = capture_logs { transaction._sample }
+      expect(logs).to contains_log(
+        :error,
+        "Exception while fetching headers: RuntimeError: uh oh"
+      )
     end
 
-    context "when the given headers is nil" do
-      it "does not update the headers on the transaction" do
-        headers = { "PATH_INFO" => "value" }
-        transaction.set_headers(headers)
-        transaction.set_headers(nil)
+    it "does not update the headers on the transaction if the given value is nil" do
+      headers = { "PATH_INFO" => "value" }
+      transaction.add_headers(headers)
+      transaction.add_headers(nil)
+
+      transaction._sample
+      expect(transaction).to include_environment(headers)
+    end
+
+    context "with request_headers options" do
+      let(:options) { { :request_headers => ["MY_HEADER"] } }
+
+      it "does not include filtered out headers" do
+        transaction.add_headers("MY_HEADER" => "value1", "filtered_key" => "filtered_value")
 
         transaction._sample
-        expect(transaction).to include_environment(headers)
+        expect(transaction).to include_environment("MY_HEADER" => "value1")
       end
     end
   end
 
-  describe "#set_headers_if_nil" do
+  describe "#add_headers_if_nil" do
     let(:transaction) { new_transaction }
 
-    context "when the params are not set" do
-      it "sets the params on the transaction" do
+    it "has a #set_headers_if_nil alias" do
+      expect(transaction.method(:add_headers_if_nil)).to eq(transaction.method(:set_headers_if_nil))
+    end
+
+    context "when the headers are not set" do
+      it "adds the headers to the transaction" do
         headers = { "PATH_INFO" => "value" }
-        transaction.set_headers_if_nil(headers)
+        transaction.add_headers_if_nil(headers)
 
         transaction._sample
         expect(transaction).to include_environment(headers)
       end
 
-      it "updates the params on the transaction with a block" do
+      it "adds the headers to the transaction with a block" do
         headers = { "PATH_INFO" => "value" }
-        transaction.set_headers_if_nil { headers }
+        transaction.add_headers_if_nil { headers }
 
         transaction._sample
         expect(transaction).to include_environment(headers)
       end
 
-      it "updates with the params argument when both an argument and block are given" do
+      it "adds the headers block value when both an argument and block are given" do
         arg_data = { "PATH_INFO" => "/arg-path" }
         block_data = { "PATH_INFO" => "/block-path" }
-        transaction.set_headers_if_nil(arg_data) { block_data }
+        transaction.add_headers_if_nil(arg_data) { block_data }
 
         transaction._sample
-        expect(transaction).to include_environment(arg_data)
+        expect(transaction).to include_environment(block_data)
       end
 
-      context "when the given params is nil" do
-        it "does not update the params on the transaction" do
-          headers = { "PATH_INFO" => "value" }
-          transaction.set_headers(headers)
-          transaction.set_headers_if_nil(nil)
+      it "does not update the headers on the transaction if the given value is nil" do
+        headers = { "PATH_INFO" => "value" }
+        transaction.add_headers(headers)
+        transaction.add_headers_if_nil(nil)
 
-          transaction._sample
-          expect(transaction).to include_environment(headers)
-        end
+        transaction._sample
+        expect(transaction).to include_environment(headers)
       end
     end
 
-    context "when the params are set" do
-      it "does not update the params on the transaction" do
+    context "when the headers are set" do
+      it "does not update the headers on the transaction" do
         preset_headers = { "PATH_INFO" => "/first-path" }
         headers = { "PATH_INFO" => "/other-path" }
-        transaction.set_headers(preset_headers)
-        transaction.set_headers_if_nil(headers)
+        transaction.add_headers(preset_headers)
+        transaction.add_headers_if_nil(headers)
 
         transaction._sample
         expect(transaction).to include_environment(preset_headers)
       end
 
-      it "does not update the params with a block on the transaction" do
+      it "does not update the headers with a block on the transaction" do
         preset_headers = { "PATH_INFO" => "/first-path" }
         headers = { "PATH_INFO" => "/other-path" }
-        transaction.set_headers(preset_headers)
-        transaction.set_headers_if_nil { headers }
+        transaction.add_headers(preset_headers)
+        transaction.add_headers_if_nil { headers }
 
         transaction._sample
         expect(transaction).to include_environment(preset_headers)
@@ -867,12 +1014,12 @@ describe Appsignal::Transaction do
     end
   end
 
-  describe "#set_tags" do
+  describe "#add_tags" do
     let(:transaction) { new_transaction }
     let(:long_string) { "a" * 10_001 }
 
     it "stores tags on the transaction" do
-      transaction.set_tags(
+      transaction.add_tags(
         :valid_key => "valid_value",
         "valid_string_key" => "valid_value",
         :both_symbols => :valid_value,
@@ -900,8 +1047,8 @@ describe Appsignal::Transaction do
     end
 
     it "merges the tags when called multiple times" do
-      transaction.set_tags(:key1 => "value1")
-      transaction.set_tags(:key2 => "value2")
+      transaction.add_tags(:key1 => "value1")
+      transaction.add_tags(:key2 => "value2")
       transaction._sample
 
       expect(transaction).to include_tags(
@@ -911,11 +1058,15 @@ describe Appsignal::Transaction do
     end
   end
 
-  describe "#set_custom_data" do
+  describe "#add_custom_data" do
     let(:transaction) { new_transaction }
 
-    it "stores custom Hash data on the transaction" do
-      transaction.set_custom_data(
+    it "has a #add_custom_data alias" do
+      expect(transaction.method(:add_custom_data)).to eq(transaction.method(:set_custom_data))
+    end
+
+    it "adds a custom Hash data to the transaction" do
+      transaction.add_custom_data(
         :user => {
           :id => 123,
           :locale => "abc"
@@ -939,8 +1090,8 @@ describe Appsignal::Transaction do
       )
     end
 
-    it "stores custom Array data on the transaction" do
-      transaction.set_custom_data([
+    it "adds a custom Array data to the transaction" do
+      transaction.add_custom_data([
         [123, "abc"],
         ["appsignal", "enterprise"]
       ])
@@ -955,39 +1106,42 @@ describe Appsignal::Transaction do
     it "does not store non Hash or Array custom data" do
       logs =
         capture_logs do
-          transaction.set_custom_data("abc")
+          transaction.add_custom_data("abc")
           transaction._sample
           expect(transaction).to_not include_custom_data
 
-          transaction.set_custom_data(123)
+          transaction.add_custom_data(123)
           transaction._sample
           expect(transaction).to_not include_custom_data
 
-          transaction.set_custom_data(Object.new)
+          transaction.add_custom_data(Object.new)
           transaction._sample
           expect(transaction).to_not include_custom_data
         end
 
       expect(logs).to contains_log(
         :error,
-        "set_custom_data: Unsupported data type String received."
+        %(Sample data 'custom_data': Unsupported data type 'String' received: "abc")
       )
       expect(logs).to contains_log(
         :error,
-        "set_custom_data: Unsupported data type Integer received."
+        %(Sample data 'custom_data': Unsupported data type 'Integer' received: 123)
       )
       expect(logs).to contains_log(
         :error,
-        "set_custom_data: Unsupported data type String received."
+        %(Sample data 'custom_data': Unsupported data type 'Object' received: #<Object:)
       )
     end
 
-    it "overwrites the custom data if called multiple times" do
-      transaction.set_custom_data("user" => { "id" => 123 })
-      transaction.set_custom_data("user" => { "id" => 456 })
+    it "merges the custom data if called multiple times" do
+      transaction.add_custom_data("abc" => "value")
+      transaction.add_custom_data("def" => "value")
 
       transaction._sample
-      expect(transaction).to include_custom_data("user" => { "id" => 456 })
+      expect(transaction).to include_custom_data(
+        "abc" => "value",
+        "def" => "value"
+      )
     end
   end
 
@@ -1150,42 +1304,6 @@ describe Appsignal::Transaction do
     end
   end
 
-  describe "#set_http_or_background_action" do
-    let(:transaction) { new_transaction }
-
-    context "for a hash with controller and action" do
-      it "sets the action" do
-        transaction.set_http_or_background_action(
-          :controller => "HomeController",
-          :action => "show"
-        )
-        expect(transaction).to have_action("HomeController#show")
-      end
-    end
-
-    context "for a hash with just action" do
-      it "sets the action" do
-        transaction.set_http_or_background_action(:action => "show")
-        expect(transaction).to have_action("show")
-      end
-    end
-
-    context "for a hash with class and method" do
-      it "sets the action" do
-        transaction.set_http_or_background_action(:class => "Worker", :method => "perform")
-        expect(transaction).to have_action("Worker#perform")
-      end
-    end
-
-    context "when action is already set" do
-      it "does not overwrite the set action" do
-        transaction.set_action("MyCustomAction#perform")
-        transaction.set_http_or_background_action(:class => "Worker", :method => "perform")
-        expect(transaction).to have_action("MyCustomAction#perform")
-      end
-    end
-  end
-
   describe "#set_queue_start" do
     let(:transaction) { new_transaction }
 
@@ -1210,75 +1328,6 @@ describe Appsignal::Transaction do
     end
   end
 
-  describe "#set_http_or_background_queue_start" do
-    let(:transaction) { legacy_new_transaction(:request => legacy_request(env)) }
-    let(:err_stream) { std_stream }
-    let(:stderr) { err_stream.read }
-    let(:header_factor) { 1_000 }
-    let(:env_queue_start) { fixed_time + 20 } # in seconds
-
-    def set_http_or_background_queue_start
-      capture_std_streams(std_stream, err_stream) do
-        transaction.set_http_or_background_queue_start
-      end
-    end
-
-    context "when a queue time is found in a request header" do
-      let(:header_time) { ((fixed_time + 10) * header_factor).to_i } # in milliseconds
-      let(:env) { { "HTTP_X_REQUEST_START" => "t=#{header_time}" } }
-
-      it "sets the http header value in milliseconds on the transaction" do
-        set_http_or_background_queue_start
-
-        expect(transaction).to have_queue_start(1_389_783_610_000)
-      end
-
-      it "logs a deprecation message" do
-        logs = capture_logs { set_http_or_background_queue_start }
-
-        expect(logs).to contains_log(
-          :warn,
-          "The Appsignal::Transaction#set_http_or_background_queue_start " \
-            "method has been deprecated."
-        )
-      end
-
-      it "prints a deprecation message" do
-        set_http_or_background_queue_start
-
-        expect(stderr).to include(
-          "The Appsignal::Transaction#set_http_or_background_queue_start " \
-            "method has been deprecated."
-        )
-      end
-
-      context "when a :queue_start key is found in the transaction environment" do
-        let(:env) do
-          {
-            "HTTP_X_REQUEST_START" => "t=#{header_time}",
-            :queue_start => env_queue_start
-          }
-        end
-
-        it "sets the http header value in milliseconds on the transaction" do
-          set_http_or_background_queue_start
-
-          expect(transaction).to have_queue_start(1_389_783_610_000)
-        end
-      end
-    end
-
-    context "when a :queue_start key is found in the transaction environment" do
-      let(:env) { { :queue_start => env_queue_start } } # in seconds
-
-      it "sets the :queue_start value in milliseconds on the transaction" do
-        set_http_or_background_queue_start
-
-        expect(transaction).to have_queue_start(1_389_783_620_000)
-      end
-    end
-  end
-
   describe "#set_metadata" do
     let(:transaction) { new_transaction }
 
@@ -1289,8 +1338,7 @@ describe Appsignal::Transaction do
     end
 
     context "when filter_metadata includes metadata key" do
-      before { Appsignal.config[:filter_metadata] = ["filter_key"] }
-      after { Appsignal.config[:filter_metadata] = [] }
+      let(:options) { { :filter_metadata => ["filter_key"] } }
 
       it "does not set the metadata on the transaction" do
         transaction.set_metadata(:filter_key, "filtered value")
@@ -1363,14 +1411,22 @@ describe Appsignal::Transaction do
           expect(transaction).to_not include_params
         end
 
-      expect(logs).to contains_log :error,
-        %(Invalid sample data for 'params'. Value is not an Array or Hash: '"some string"')
-      expect(logs).to contains_log :error,
-        %(Invalid sample data for 'params'. Value is not an Array or Hash: '123')
-      expect(logs).to contains_log :error,
-        %(Invalid sample data for 'params'. Value is not an Array or Hash: '"#<Class>"')
-      expect(logs).to contains_log :error,
-        %(Invalid sample data for 'params'. Value is not an Array or Hash: '"#<Set>"')
+      expect(logs).to contains_log(
+        :error,
+        %(Sample data 'params': Unsupported data type 'String' received: "some string")
+      )
+      expect(logs).to contains_log(
+        :error,
+        %(Sample data 'params': Unsupported data type 'Integer' received: 123)
+      )
+      expect(logs).to contains_log(
+        :error,
+        %(Sample data 'params': Unsupported data type 'Class' received: #<Class)
+      )
+      expect(logs).to contains_log(
+        :error,
+        %(Sample data 'params': Unsupported data type 'Set' received: #<Set: {"some value"}>)
+      )
     end
 
     it "does not store data that can't be converted to JSON" do
@@ -1400,7 +1456,8 @@ describe Appsignal::Transaction do
 
     it "updates the sample data on the transaction" do
       silence do
-        transaction.set_sample_data(
+        transaction.send(
+          :set_sample_data,
           "params",
           :controller => "blog_posts",
           :action     => "show",
@@ -1419,7 +1476,7 @@ describe Appsignal::Transaction do
       it "does not update the sample data on the transaction" do
         logs =
           capture_logs do
-            silence { transaction.set_sample_data("params", "string") }
+            silence { transaction.send(:set_sample_data, "params", "string") }
           end
 
         expect(transaction.to_h["sample_data"]).to eq({})
@@ -1437,7 +1494,7 @@ describe Appsignal::Transaction do
         end
         logs =
           capture_logs do
-            silence { transaction.set_sample_data("params", klass.new => 1) }
+            silence { transaction.send(:set_sample_data, "params", klass.new => 1) }
           end
 
         expect(transaction).to_not include_params
@@ -1447,91 +1504,202 @@ describe Appsignal::Transaction do
     end
   end
 
-  describe "#sample_data" do
-    let(:transaction) { legacy_new_transaction(:request => rack_request(env)) }
-    let(:env) do
-      Rack::MockRequest.env_for(
-        "/blog",
-        "REQUEST_METHOD" => "GET",
-        "SERVER_NAME" => "example.org",
-        "SERVER_PORT" => "80",
-        "PATH_INFO" => "/blog",
-        "rack.session" => { "session" => "value" },
-        :params => {
-          "controller" => "blog_posts",
-          "action" => "show",
-          "id" => "1"
-        }
-      ).merge(
-        :metadata => { "metadata" => "value" }
-      )
+  describe "#add_error" do
+    let(:transaction) { create_transaction }
+
+    let(:error) do
+      e = ExampleStandardError.new("test message")
+      allow(e).to receive(:backtrace).and_return(["line 1"])
+      e
     end
 
-    it "sets sample data from request" do
-      transaction.set_tags "tag" => "value"
-      transaction.add_breadcrumb "category", "action", "message", "key" => "value"
-      silence { transaction.sample_data }
+    context "when error argument is not an error" do
+      let(:error) { Object.new }
+
+      it "does not add the error" do
+        logs = capture_logs { transaction.add_error(error) }
 
-      expect(transaction).to include_environment(
-        "REQUEST_METHOD" => "GET",
-        "SERVER_NAME" => "example.org",
-        "SERVER_PORT" => "80",
-        "PATH_INFO" => "/blog"
-      )
-      expect(transaction).to include_session_data("session" => "value")
-      expect(transaction).to include_params(
-        "controller" => "blog_posts",
-        "action" => "show",
-        "id" => "1"
-      )
-      expect(transaction).to include_sample_metadata("metadata" => "value")
-      expect(transaction).to include_tags("tag" => "value")
-      expect(transaction).to include_breadcrumb(
-        "action",
-        "category",
-        "message",
-        { "key" => "value" },
-        kind_of(Integer)
-      )
+        expect(transaction).to_not have_error
+        expect(logs).to contains_log(
+          :error,
+          "Appsignal::Transaction#add_error: Cannot add error. " \
+            "The given value is not an exception: #{error.inspect}"
+        )
+      end
     end
-  end
 
-  describe "#set_error" do
-    let(:transaction) { new_transaction }
-    let(:env) { http_request_env_with_data }
-    let(:error) { ExampleStandardError.new("test message") }
+    context "when AppSignal is not active" do
+      it "does not add the error" do
+        allow(Appsignal).to receive(:active?).and_return(false)
 
-    it "responds to add_exception for backwards compatibility" do
-      expect(transaction).to respond_to(:add_exception)
+        transaction.add_error(error)
+
+        expect(transaction).to_not have_error
+      end
+    end
+
+    context "when a block is given" do
+      it "stores the block in the error blocks" do
+        block = proc { "block" }
+
+        transaction.add_error(error, &block)
+
+        expect(transaction.error_blocks).to eq({
+          error => [block]
+        })
+      end
     end
 
-    it "does not add the error if not active" do
-      allow(Appsignal).to receive(:active?).and_return(false)
+    context "when no error is set in the transaction" do
+      it "sets the error on the transaction" do
+        transaction.add_error(error)
+
+        expect(transaction).to have_error(
+          "ExampleStandardError",
+          "test message",
+          ["line 1"]
+        )
+      end
 
-      transaction.set_error(error)
+      it "does store the error in the errors" do
+        transaction.add_error(error)
 
-      expect(transaction).to_not have_error
+        expect(transaction.error_blocks).to eq({ error => [] })
+      end
     end
 
-    context "when error argument is not an error" do
-      let(:error) { Object.new }
+    context "when an error is already set in the transaction" do
+      let(:other_error) do
+        e = ExampleStandardError.new("other test message")
+        allow(e).to receive(:backtrace).and_return(["line 2"])
+        e
+      end
 
-      it "does not add the error" do
-        logs = capture_logs { transaction.set_error(error) }
+      before { transaction.set_error(other_error) }
+
+      it "stores an error in the errors" do
+        transaction.add_error(error)
+
+        expect(transaction.error_blocks).to eq({
+          other_error => [],
+          error => []
+        })
+      end
+
+      it "does not set the error on the extension" do
+        transaction.add_error(error)
+
+        expect(transaction).to have_error(
+          "ExampleStandardError",
+          "other test message",
+          ["line 2"]
+        )
+      end
+    end
+
+    context "when the error has already been added" do
+      before { transaction.add_error(error) }
+
+      it "does not add the error to the errors" do
+        expect(transaction.error_blocks).to eq({ error => [] })
+
+        transaction.add_error(error)
+
+        expect(transaction.error_blocks).to eq({ error => [] })
+      end
+
+      context "when a block is given" do
+        it "adds the block to the error blocks" do
+          block = proc { "block" }
+
+          transaction.add_error(error, &block)
+
+          expect(transaction.error_blocks).to eq({ error => [block] })
+        end
+      end
+    end
+
+    context "when the errors is at the limit" do
+      let(:seen_error) { ExampleStandardError.new("error 0") }
+
+      before do
+        transaction.add_error(seen_error)
+
+        9.times do |i|
+          transaction.add_error(ExampleStandardError.new("error #{i}"))
+        end
+      end
+
+      it "does not add a new error to the errors" do
+        expect(transaction).to have_error("ExampleStandardError", "error 0", [])
+        expect(transaction.error_blocks.length).to eq(10)
+        expected_error_blocks = transaction.error_blocks.dup
+
+        transaction.add_error(error)
+
+        expect(transaction).to have_error("ExampleStandardError", "error 0", [])
+        expect(transaction.error_blocks).to eq(expected_error_blocks)
+      end
+
+      it "logs a debug message" do
+        logs = capture_logs { transaction.add_error(error) }
 
-        expect(transaction).to_not have_error
         expect(logs).to contains_log(
-          :error,
-          "Appsignal::Transaction#set_error: Cannot set error. " \
-            "The given value is not an exception: #{error.inspect}"
+          :warn,
+          "Appsignal::Transaction#add_error: Transaction has more than 10 distinct errors. " \
+            "Only the first 10 distinct errors will be reported."
         )
       end
+
+      context "when the error has already been added" do
+        it "does not add the error to the errors" do
+          expect(transaction.error_blocks.length).to eq(10)
+
+          transaction.add_error(seen_error)
+
+          expect(transaction.error_blocks.length).to eq(10)
+        end
+
+        it "does add the block to the error blocks" do
+          block = proc { "block" }
+
+          transaction.add_error(seen_error, &block)
+
+          expect(transaction.error_blocks[seen_error]).to eq([block])
+        end
+
+        it "does not log a debug message" do
+          logs = capture_logs { transaction.add_error(seen_error) }
+
+          expect(logs).to_not contains_log(
+            :warn,
+            "Appsignal::Transaction#add_error: Transaction has more than 10 distinct errors. " \
+              "Only the first 10 distinct errors will be reported."
+          )
+        end
+      end
+    end
+  end
+
+  describe "#_set_error" do
+    let(:transaction) { new_transaction }
+    let(:env) { http_request_env_with_data }
+    let(:error) { ExampleStandardError.new("test message") }
+
+    it "responds to add_exception for backwards compatibility" do
+      expect(transaction).to respond_to(:add_exception)
+    end
+
+    it "does not add the error to the errors" do
+      transaction.send(:_set_error, error)
+
+      expect(transaction.error_blocks).to be_empty
     end
 
     context "for a http request" do
       it "sets an error on the transaction" do
         allow(error).to receive(:backtrace).and_return(["line 1"])
-        transaction.set_error(error)
+        transaction.send(:_set_error, error)
 
         expect(transaction).to have_error(
           "ExampleStandardError",
@@ -1542,10 +1710,10 @@ describe Appsignal::Transaction do
     end
 
     context "when the error has no causes" do
-      it "does not set the causes information as sample data" do
-        transaction.set_error(error)
+      it "should set an empty causes array as sample data" do
+        transaction.send(:_set_error, error)
 
-        expect(transaction).to_not include_error_causes
+        expect(transaction).to include_error_causes([])
       end
     end
 
@@ -1560,8 +1728,12 @@ describe Appsignal::Transaction do
         e
       end
 
+      let(:error_without_cause) do
+        ExampleStandardError.new("error without cause")
+      end
+
       it "sends the causes information as sample data" do
-        transaction.set_error(error)
+        transaction.send(:_set_error, error)
 
         expect(transaction).to have_error(
           "ExampleStandardError",
@@ -1581,6 +1753,19 @@ describe Appsignal::Transaction do
           ]
         )
       end
+
+      it "does not keep error causes from previously set errors" do
+        transaction.send(:_set_error, error)
+        transaction.send(:_set_error, error_without_cause)
+
+        expect(transaction).to have_error(
+          "ExampleStandardError",
+          "error without cause",
+          []
+        )
+
+        expect(transaction).to include_error_causes([])
+      end
     end
 
     context "when the error has too many causes" do
@@ -1607,7 +1792,7 @@ describe Appsignal::Transaction do
           end
         expected_error_causes.last["is_root_cause"] = false
 
-        logs = capture_logs { transaction.set_error(error) }
+        logs = capture_logs { transaction.send(:_set_error, error) }
 
         expect(transaction).to have_error(
           "ExampleStandardError",
@@ -1617,7 +1802,7 @@ describe Appsignal::Transaction do
         expect(transaction).to include_error_causes(expected_error_causes)
         expect(logs).to contains_log(
           :debug,
-          "Appsignal::Transaction#set_error: Error has more " \
+          "Appsignal::Transaction#add_error: Error has more " \
             "than 10 error causes. Only the first 10 " \
             "will be reported."
         )
@@ -1633,11 +1818,11 @@ describe Appsignal::Transaction do
       end
 
       it "does not raise an error" do
-        transaction.set_error(error)
+        transaction.send(:_set_error, error)
       end
 
       it "sets an error on the transaction without an error message" do
-        transaction.set_error(error)
+        transaction.send(:_set_error, error)
 
         expect(transaction).to have_error(
           "ExampleStandardError",
@@ -1780,433 +1965,8 @@ describe Appsignal::Transaction do
     end
   end
 
-  context "GenericRequest" do
-    let(:env) { {} }
-    subject { Appsignal::Transaction::GenericRequest.new(env) }
-
-    it "prints a deprecation warning on use" do
-      err_stream = std_stream
-      capture_std_streams(std_stream, err_stream) { subject }
-
-      expect(err_stream.read).to include(
-        "appsignal WARNING: The use of Appsignal::Transaction::GenericRequest is deprecated."
-      )
-    end
-
-    it "logs a deprecation warning on use" do
-      logs = capture_logs { silence { subject } }
-
-      expect(logs).to contains_log(
-        :warn,
-        "The use of Appsignal::Transaction::GenericRequest is deprecated."
-      )
-    end
-
-    it "initializes with an empty env" do
-      expect(subject.env).to be_empty
-    end
-
-    context "when given an env" do
-      let(:env) do
-        {
-          :params => { :id => 1 },
-          :queue_start => 10
-        }
-      end
-
-      it "sets the given env" do
-        expect(subject.env).to eq env
-      end
-
-      it "sets the params present in the env" do
-        expect(subject.params).to eq(:id => 1)
-      end
-    end
-  end
-
   # private
 
-  describe "#background_queue_start" do
-    let(:transaction) { legacy_new_transaction(:request => request) }
-    let(:request) { rack_request(env) }
-    let(:env) { {} }
-    subject { transaction.send(:background_queue_start) }
-
-    context "when request is nil" do
-      let(:request) { nil }
-
-      it { is_expected.to eq nil }
-    end
-
-    context "when env is nil" do
-      before { expect(request).to receive(:env).and_return(nil) }
-
-      it { is_expected.to eq nil }
-    end
-
-    context "when queue start is nil" do
-      it { is_expected.to eq nil }
-    end
-
-    context "when queue start is set" do
-      before do
-        env[:queue_start] = fixed_time
-      end
-
-      it { is_expected.to eq 1_389_783_600_000 }
-    end
-  end
-
-  describe "#http_queue_start" do
-    let(:transaction) { legacy_new_transaction(:request => request) }
-    let(:request) { rack_request(env) }
-    let(:env) { {} }
-    let(:slightly_earlier_time) { fixed_time - 0.4 }
-    let(:slightly_earlier_time_value) { (slightly_earlier_time * factor).to_i }
-    subject { transaction.send(:http_queue_start) }
-
-    shared_examples "http queue start" do
-      context "when request is nil" do
-        let(:request) { nil }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "when env is nil" do
-        before { expect(request).to receive(:env).and_return(nil) }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "with no relevant header set" do
-        let(:env) { {} }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "with the HTTP_X_REQUEST_START header set" do
-        let(:env) { { "HTTP_X_REQUEST_START" => "t=#{slightly_earlier_time_value}" } }
-
-        it { is_expected.to eq 1_389_783_599_600 }
-
-        context "with unparsable content" do
-          let(:env) { { "HTTP_X_REQUEST_START" => "something" } }
-
-          it { is_expected.to be_nil }
-        end
-
-        context "with unparsable content at the end" do
-          let(:env) { { "HTTP_X_REQUEST_START" => "t=#{slightly_earlier_time_value}aaaa" } }
-
-          it { is_expected.to eq 1_389_783_599_600 }
-        end
-
-        context "with a really low number" do
-          let(:env) { { "HTTP_X_REQUEST_START" => "t=100" } }
-
-          it { is_expected.to be_nil }
-        end
-
-        context "with the alternate HTTP_X_QUEUE_START header set" do
-          let(:env) { { "HTTP_X_QUEUE_START" => "t=#{slightly_earlier_time_value}" } }
-
-          it { is_expected.to eq 1_389_783_599_600 }
-        end
-      end
-    end
-
-    context "time in milliseconds" do
-      let(:factor) { 1_000 }
-
-      it_should_behave_like "http queue start"
-    end
-
-    context "time in microseconds" do
-      let(:factor) { 1_000_000 }
-
-      it_should_behave_like "http queue start"
-    end
-  end
-
-  describe "#sanitized_params" do
-    let(:transaction) { new_transaction }
-    subject { transaction.send(:sanitized_params) }
-
-    context "with params" do
-      before do
-        transaction.set_params(:foo => "bar", :baz => :bat)
-      end
-
-      it "returns params" do
-        is_expected.to eq(:foo => "bar", :baz => :bat)
-      end
-
-      context "with AppSignal filtering" do
-        before { Appsignal.config.config_hash[:filter_parameters] = %w[foo] }
-        after { Appsignal.config.config_hash[:filter_parameters] = [] }
-
-        it "returns sanitized custom params" do
-          expect(subject).to eq(:foo => "[FILTERED]", :baz => :bat)
-        end
-      end
-    end
-
-    context "params from request" do
-      let(:transaction) { legacy_new_transaction(:request => request, :options => options) }
-      let(:options) { {} }
-      let(:request) { rack_request(env) }
-      let(:env) { {} }
-
-      context "without request params" do
-        before { allow(transaction.request).to receive(:params).and_return(nil) }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "when request params crashes" do
-        before { expect(request).to receive(:params).and_raise(NoMethodError) }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "when request params method does not exist" do
-        let(:options) { { :params_method => :nonsense } }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "when not sending params" do
-        before { Appsignal.config.config_hash[:send_params] = false }
-        after { Appsignal.config.config_hash[:send_params] = true }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "with an array" do
-        let(:request) { legacy_request(:params => %w[arg1 arg2]) }
-
-        it { is_expected.to eq %w[arg1 arg2] }
-
-        context "with AppSignal filtering" do
-          before { Appsignal.config.config_hash[:filter_parameters] = %w[foo] }
-          after { Appsignal.config.config_hash[:filter_parameters] = [] }
-
-          it { is_expected.to eq %w[arg1 arg2] }
-        end
-      end
-
-      context "with env" do
-        context "with sanitization" do
-          let(:request) { legacy_request(:params => { :foo => :bar }) }
-
-          it "should call the params sanitizer" do
-            expect(subject).to eq(:foo => :bar)
-          end
-        end
-
-        context "with AppSignal filtering" do
-          let(:request) { legacy_request(:params => { :foo => :bar, :baz => :bat }) }
-          before { Appsignal.config.config_hash[:filter_parameters] = %w[foo] }
-          after { Appsignal.config.config_hash[:filter_parameters] = [] }
-
-          it "should call the params sanitizer with filtering" do
-            expect(subject).to eq(:foo => "[FILTERED]", :baz => :bat)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#sanitized_environment" do
-    let(:transaction) { legacy_new_transaction(:request => request) }
-    let(:request) { rack_request(env) }
-    let(:env) { {} }
-    let(:allowlisted_keys) { Appsignal.config[:request_headers] }
-    subject { transaction.send(:sanitized_environment) }
-
-    context "when request is nil" do
-      let(:request) { nil }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "when env is nil" do
-      before { expect(request).to receive(:env).and_return(nil) }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "when env is present" do
-      let(:env) do
-        {}.tap do |hash|
-          allowlisted_keys.each { |o| hash[o] = 1 } # use all allowlisted keys
-          hash[allowlisted_keys] = nil # don't add if nil
-          hash[:not_allowlisted] = "I will be sanitized"
-        end
-      end
-
-      it "only sets allowlisted keys" do
-        expect(subject.keys).to match_array(allowlisted_keys)
-      end
-
-      context "with configured request_headers" do
-        before do
-          Appsignal.config.config_hash[:request_headers] = %w[CONTENT_LENGTH]
-        end
-
-        it "only sets allowlisted keys" do
-          expect(subject.keys).to match_array(%w[CONTENT_LENGTH])
-        end
-      end
-    end
-  end
-
-  describe "#sanitized_session_data" do
-    let(:transaction) { legacy_new_transaction(:request => request) }
-    let(:request) { rack_request(env) }
-    let(:env) { {} }
-    subject { transaction.send(:sanitized_session_data) }
-
-    context "when request is nil" do
-      let(:request) { nil }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "when session is nil" do
-      before { expect(transaction.request).to receive(:session).and_return(nil) }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "when session is empty" do
-      before { expect(transaction.request).to receive(:session).and_return({}) }
-
-      it { is_expected.to eq({}) }
-    end
-
-    context "when request class does not have a session method" do
-      let(:request) { Appsignal::Transaction::GenericRequest.new({}) }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "with a session" do
-      let(:session_data_filter) { [] }
-      before { Appsignal.config[:filter_session_data] = session_data_filter }
-      after { Appsignal.config[:filter_session_data] = [] }
-
-      context "with generic session object" do
-        before do
-          expect(transaction).to respond_to(:request)
-          allow(transaction).to receive_message_chain(
-            :request,
-            :session => { :foo => :bar, :abc => :def }
-          )
-          allow(transaction).to receive_message_chain(:request, :fullpath => :bar)
-        end
-
-        context "without session filtering" do
-          it "keeps the session data intact" do
-            expect(subject).to eq(:foo => :bar, :abc => :def)
-          end
-        end
-
-        context "with session filtering" do
-          let(:session_data_filter) { %w[foo] }
-
-          it "filters the session data" do
-            expect(subject).to eq(:foo => "[FILTERED]", :abc => :def)
-          end
-        end
-      end
-
-      if defined? ActionDispatch::Request::Session
-        context "with ActionDispatch::Request::Session" do
-          let(:action_dispatch_session) do
-            store = Class.new do
-              def load_session(_env)
-                [1, { :foo => :bar, :abc => :def }]
-              end
-
-              def session_exists?(_env)
-                true
-              end
-            end.new
-            ActionDispatch::Request::Session.create(store,
-              ActionDispatch::Request.new("rack.input" => StringIO.new), {})
-          end
-          before do
-            expect(transaction).to respond_to(:request)
-            allow(transaction).to receive_message_chain(
-              :request,
-              :session => action_dispatch_session
-            )
-            allow(transaction).to receive_message_chain(:request, :fullpath => :bar)
-          end
-
-          context "without session filtering" do
-            it "keeps the session data intact" do
-              expect(subject).to eq("foo" => :bar, "abc" => :def)
-            end
-          end
-
-          context "with session filtering" do
-            let(:session_data_filter) { %w[foo] }
-
-            it "filters the session data" do
-              expect(subject).to eq("foo" => "[FILTERED]", "abc" => :def)
-            end
-          end
-        end
-      end
-
-      context "when not sending session data" do
-        before { Appsignal.config[:send_session_data] = false }
-
-        it "does not set any session data on the transaction" do
-          expect(subject).to be_nil
-        end
-      end
-    end
-  end
-
-  describe "#sanitized_metadata" do
-    let(:transaction) { legacy_new_transaction(:request => request) }
-    let(:request) { rack_request(env) }
-    let(:env) { {} }
-    subject { transaction.send(:sanitized_metadata) }
-
-    context "when request is nil" do
-      let(:request) { nil }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "when env is nil" do
-      before { expect(request).to receive(:env).and_return(nil) }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "when env is present" do
-      let(:env) { { :metadata => { "key" => "value" } } }
-
-      it do
-        is_expected.to eq("key" => "value")
-      end
-
-      context "with filter_metadata option set" do
-        before { Appsignal.config[:filter_metadata] = ["key"] }
-        after { Appsignal.config[:filter_metadata] = [] }
-
-        it "filters out keys listed in the filter_metadata option" do
-          expect(subject.keys).to_not include("key")
-        end
-      end
-    end
-  end
-
   describe "#cleaned_backtrace" do
     let(:transaction) { new_transaction }
     subject { transaction.send(:cleaned_backtrace, ["line 1", "line 2"]) }
@@ -2313,13 +2073,13 @@ describe Appsignal::Transaction do
   describe Appsignal::Transaction::NilTransaction do
     subject { Appsignal::Transaction::NilTransaction.new }
 
-    it "should have method stubs" do
+    it "has method stubs" do
       subject.complete
       subject.pause!
       subject.resume!
       subject.paused?
       subject.store(:key)
-      subject.set_tags(:tag => 1)
+      subject.add_tags(:tag => 1)
       subject.set_action("action")
       subject.set_http_or_background_action
       subject.set_queue_start(1)