appsignal 2.2.1 → 2.3.0.beta.1

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

@@ -2,13 +2,14 @@ describe Appsignal::Hooks::SidekiqPlugin do
   let(:worker) { double }
   let(:queue) { double }
   let(:current_transaction) { background_job_transaction }
+  let(:args) { ["Model", 1] }
   let(:item) do
     {
       "class"       => "TestClass",
       "retry_count" => 0,
       "queue"       => "default",
       "enqueued_at" => Time.parse("01-01-2001 10:00:00UTC"),
-      "args"        => ["Model", 1],
+      "args"        => args,
       "extra"       => "data"
     }
   end
@@ -20,7 +21,15 @@ describe Appsignal::Hooks::SidekiqPlugin do
   end
 
   context "with a performance call" do
-    it "should wrap in a transaction with the correct params" do
+    after do
+      Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
+        Appsignal::Hooks::SidekiqPlugin.new.call(worker, item, queue) do
+          # nothing
+        end
+      end
+    end
+
+    it "wraps it in a transaction with the correct params" do
       expect(Appsignal).to receive(:monitor_transaction).with(
         "perform_job.sidekiq",
         :class    => "TestClass",
@@ -30,12 +39,69 @@ describe Appsignal::Hooks::SidekiqPlugin do
           "queue"       => "default",
           "extra"       => "data"
         },
-        :params      => %w(Model 1),
+        :params      => ["Model", 1],
         :queue_start => Time.parse("01-01-2001 10:00:00UTC"),
         :queue_time  => 60_000.to_f
       )
     end
 
+    context "with more complex arguments" do
+      let(:default_params) do
+        {
+          :class    => "TestClass",
+          :method   => "perform",
+          :metadata => {
+            "retry_count" => "0",
+            "queue"       => "default",
+            "extra"       => "data"
+          },
+          :params => {
+            :foo => "Foo",
+            :bar => "Bar"
+          },
+          :queue_start => Time.parse("01-01-2001 10:00:00UTC"),
+          :queue_time  => 60_000.to_f
+        }
+      end
+      let(:args) do
+        {
+          :foo => "Foo",
+          :bar => "Bar"
+        }
+      end
+
+      it "adds the more complex arguments" do
+        expect(Appsignal).to receive(:monitor_transaction).with(
+          "perform_job.sidekiq",
+          default_params.merge(
+            :params => {
+              :foo => "Foo",
+              :bar => "Bar"
+            }
+          )
+        )
+      end
+
+      context "with parameter filtering" do
+        before do
+          Appsignal.config = project_fixture_config("production")
+          Appsignal.config[:filter_parameters] = ["foo"]
+        end
+
+        it "filters selected arguments" do
+          expect(Appsignal).to receive(:monitor_transaction).with(
+            "perform_job.sidekiq",
+            default_params.merge(
+              :params => {
+                :foo => "[FILTERED]",
+                :bar => "Bar"
+              }
+            )
+          )
+        end
+      end
+    end
+
     context "when wrapped by ActiveJob" do
       let(:item) do
         {
@@ -46,7 +112,7 @@ describe Appsignal::Hooks::SidekiqPlugin do
             "job_class" => "TestJob",
             "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
             "queue_name" => "default",
-            "arguments" => ["Model", 1]
+            "arguments" => args
           }],
           "retry" => true,
           "jid" => "efb140489485999d32b5504c",
@@ -54,50 +120,103 @@ describe Appsignal::Hooks::SidekiqPlugin do
           "enqueued_at" => Time.parse("01-01-2001 10:00:00UTC").to_f
         }
       end
-
-      it "should wrap in a transaction with the correct params" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.sidekiq",
+      let(:default_params) do
+        {
           :class    => "TestClass",
           :method   => "perform",
           :metadata => {
             "queue" => "default"
           },
-          :params      => %w(Model 1),
           :queue_start => Time.parse("01-01-2001 10:00:00UTC").to_f,
           :queue_time  => 60_000.to_f
+        }
+      end
+
+      it "wraps it in a transaction with the correct params" do
+        expect(Appsignal).to receive(:monitor_transaction).with(
+          "perform_job.sidekiq",
+          default_params.merge(:params => ["Model", 1])
         )
       end
-    end
 
-    after do
-      Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-        Appsignal::Hooks::SidekiqPlugin.new.call(worker, item, queue) do
-          # nothing
+      context "with more complex arguments" do
+        let(:args) do
+          {
+            :foo => "Foo",
+            :bar => "Bar"
+          }
+        end
+
+        it "adds the more complex arguments" do
+          expect(Appsignal).to receive(:monitor_transaction).with(
+            "perform_job.sidekiq",
+            default_params.merge(
+              :params => {
+                :foo => "Foo",
+                :bar => "Bar"
+              }
+            )
+          )
+        end
+
+        context "with parameter filtering" do
+          before do
+            Appsignal.config = project_fixture_config("production")
+            Appsignal.config[:filter_parameters] = ["foo"]
+          end
+
+          it "filters selected arguments" do
+            expect(Appsignal).to receive(:monitor_transaction).with(
+              "perform_job.sidekiq",
+              default_params.merge(
+                :params => {
+                  :foo => "[FILTERED]",
+                  :bar => "Bar"
+                }
+              )
+            )
+          end
         end
       end
     end
   end
 
   context "with an erroring call" do
-    let(:error) { VerySpecificError.new }
+    let(:error) { VerySpecificError }
+    let(:transaction) do
+      Appsignal::Transaction.new(
+        SecureRandom.uuid,
+        Appsignal::Transaction::BACKGROUND_JOB,
+        Appsignal::Transaction::GenericRequest.new({})
+      )
+    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)
+    end
 
-    it "should add the exception to appsignal" do
-      expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
+    it "adds the error to the transaction" do
+      expect(transaction).to receive(:set_error).with(error)
+      expect(transaction).to receive(:complete)
     end
 
     after do
-      begin
+      expect do
         Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
           Appsignal::Hooks::SidekiqPlugin.new.call(worker, item, queue) do
             raise error
           end
         end
-      rescue VerySpecificError
-      end
+      end.to raise_error(error)
     end
   end
 
+  # TODO: Don't test (what are basically) private methods
   describe "#formatted_data" do
     let(:item) do
       {
@@ -106,7 +225,7 @@ describe Appsignal::Hooks::SidekiqPlugin do
       }
     end
 
-    it "should only add items to the hash that do not appear in JOB_KEYS" do
+    it "only adds items to the hash that do not appear in JOB_KEYS" do
       expect(plugin.formatted_metadata(item)).to eq("foo" => "bar")
     end
   end

data/spec/lib/appsignal/hooks_spec.rb

@@ -192,25 +192,4 @@ describe Appsignal::Hooks::Helpers do
       it { is_expected.to eq "1" }
     end
   end
-
-  describe "#format_args" do
-    let(:object) { Object.new }
-    let(:args) do
-      [
-        "Model",
-        1,
-        object,
-        "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
-      ]
-    end
-
-    it "should format the arguments" do
-      expect(with_helpers.format_args(args)).to eq([
-        "Model",
-        "1",
-        object.inspect,
-        "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ..."
-      ])
-    end
-  end
 end

data/spec/lib/appsignal/integrations/resque_active_job_spec.rb

@@ -1,38 +1,83 @@
 if DependencyHelper.resque_present? && DependencyHelper.active_job_present?
-  describe "Resque ActiveJob integration" do
-    let(:file) { File.expand_path("lib/appsignal/integrations/resque_active_job.rb") }
+  require "active_job"
 
-    context "with Resque and ActiveJob" do
-      before do
-        load file
-        start_agent
+  describe Appsignal::Integrations::ResqueActiveJobPlugin do
+    let(:file) { File.expand_path("lib/appsignal/integrations/resque_active_job.rb") }
+    let(:args) { "argument" }
+    let(:job) { TestActiveJob.new(args) }
+    before do
+      load file
+      start_agent
 
-        class TestActiveJob < ActiveJob::Base
-          include Appsignal::Integrations::ResqueActiveJobPlugin
+      class TestActiveJob < ActiveJob::Base
+        include Appsignal::Integrations::ResqueActiveJobPlugin
 
-          def perform(param)
-          end
+        def perform(_)
         end
       end
+    end
 
-      describe :around_perform_plugin do
-        before    { allow(SecureRandom).to receive(:uuid).and_return(123) }
-        let(:job) { TestActiveJob.new("moo") }
+    it "wraps it in a transaction with the correct params" do
+      expect(Appsignal).to receive(:monitor_single_transaction).with(
+        "perform_job.resque",
+        :class  => "TestActiveJob",
+        :method => "perform",
+        :params => ["argument"],
+        :metadata => {
+          :id    => kind_of(String),
+          :queue => "default"
+        }
+      )
+    end
+
+    context "with complex arguments" do
+      let(:args) do
+        {
+          :foo => "Foo",
+          :bar => "Bar"
+        }
+      end
 
-        it "should wrap in a transaction with the correct params" do
+      it "truncates large argument values" do
+        expect(Appsignal).to receive(:monitor_single_transaction).with(
+          "perform_job.resque",
+          :class  => "TestActiveJob",
+          :method => "perform",
+          :params => [
+            :foo => "Foo",
+            :bar => "Bar"
+          ],
+          :metadata => {
+            :id    => kind_of(String),
+            :queue => "default"
+          }
+        )
+      end
+
+      context "with parameter filtering" do
+        before do
+          Appsignal.config = project_fixture_config("production")
+          Appsignal.config[:filter_parameters] = ["foo"]
+        end
+
+        it "filters selected arguments" do
           expect(Appsignal).to receive(:monitor_single_transaction).with(
             "perform_job.resque",
             :class  => "TestActiveJob",
             :method => "perform",
-            :params => ["moo"],
+            :params => [
+              :foo => "[FILTERED]",
+              :bar => "Bar"
+            ],
             :metadata => {
-              :id    => 123,
+              :id    => kind_of(String),
               :queue => "default"
             }
           )
         end
-        after { job.perform_now }
       end
     end
+
+    after { job.perform_now }
   end
 end

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

@@ -33,11 +33,11 @@ if DependencyHelper.resque_present?
         end
 
         context "without exception" do
-          it "should create a new transaction" do
+          it "creates a new transaction" do
             expect(Appsignal::Transaction).to receive(:create).and_return(transaction)
           end
 
-          it "should wrap in a transaction with the correct params" do
+          it "wraps it in a transaction with the correct params" do
             expect(Appsignal).to receive(:monitor_transaction).with(
               "perform_job.resque",
               :class => "TestJob",
@@ -45,7 +45,7 @@ if DependencyHelper.resque_present?
             )
           end
 
-          it "should close the transaction" do
+          it "closes the transaction" do
             expect(transaction).to receive(:complete)
           end
 
@@ -54,17 +54,29 @@ if DependencyHelper.resque_present?
 
         context "with exception" do
           let(:job) { ::Resque::Job.new("default", "class" => "BrokenTestJob") }
+          let(:transaction) do
+            Appsignal::Transaction.new(
+              SecureRandom.uuid,
+              Appsignal::Transaction::BACKGROUND_JOB,
+              Appsignal::Transaction::GenericRequest.new({})
+            )
+          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)
+          end
 
-          it "should set the exception" do
-            expect_any_instance_of(Appsignal::Transaction).to receive(:set_error)
+          it "sets the exception on the transaction" do
+            expect(transaction).to receive(:set_error).with(VerySpecificError)
           end
 
           after do
-            begin
-              job.perform
-            rescue VerySpecificError
-              # Do nothing
-            end
+            expect { job.perform }.to raise_error(VerySpecificError)
           end
         end
       end
@@ -73,8 +85,8 @@ if DependencyHelper.resque_present?
     context "without resque" do
       before(:context) { Object.send(:remove_const, :Resque) }
 
-      specify { expect { ::Resque }.to raise_error(NameError) }
-      specify { expect { load file }.to_not raise_error }
+      it { expect { ::Resque }.to raise_error(NameError) }
+      it { expect { load file }.to_not raise_error }
     end
   end
 end

data/spec/lib/appsignal/transaction_spec.rb

@@ -3,151 +3,212 @@ describe Appsignal::Transaction do
     start_agent
   end
 
-  let(:time)        { Time.at(fixed_time) }
-  let(:namespace)   { Appsignal::Transaction::HTTP_REQUEST }
-  let(:env)         { {} }
-  let(:merged_env)  { http_request_env_with_data(env) }
-  let(:options)     { {} }
-  let(:request)     { Rack::Request.new(merged_env) }
-  let(:transaction) { Appsignal::Transaction.new("1", namespace, request, options) }
+  let(:transaction_id) { "1" }
+  let(:time)           { Time.at(fixed_time) }
+  let(:namespace)      { Appsignal::Transaction::HTTP_REQUEST }
+  let(:env)            { {} }
+  let(:merged_env)     { http_request_env_with_data(env) }
+  let(:options)        { {} }
+  let(:request)        { Rack::Request.new(merged_env) }
+  let(:transaction)    { Appsignal::Transaction.new(transaction_id, namespace, request, options) }
+  let(:log)            { StringIO.new }
 
   before { Timecop.freeze(time) }
-  after  { Timecop.return }
+  after { Timecop.return }
+  around do |example|
+    use_logger_with log do
+      example.run
+    end
+  end
 
   describe "class methods" do
+    def current_transaction
+      Appsignal::Transaction.current
+    end
+
     describe ".create" do
-      it "should add the transaction to thread local" do
-        expect(Appsignal::Extension).to receive(:start_transaction).with("1", "http_request", 0)
+      def create_transaction(id = transaction_id)
+        Appsignal::Transaction.create(id, namespace, request, options)
+      end
 
-        created_transaction = Appsignal::Transaction.create("1", namespace, request, options)
+      context "when no transaction is running" do
+        let!(:transaction) { create_transaction }
 
-        expect(Thread.current[:appsignal_transaction]).to eq created_transaction
-      end
+        it "returns the created transaction" do
+          expect(transaction).to be_a Appsignal::Transaction
+          expect(transaction.transaction_id).to eq transaction_id
+          expect(transaction.namespace).to eq namespace
+          expect(transaction.request).to eq request
 
-      it "should create a transaction" do
-        created_transaction = Appsignal::Transaction.create("1", namespace, request, options)
+          expect(transaction.to_h).to include(
+            "id" => transaction_id,
+            "namespace" => namespace
+          )
+        end
 
-        expect(created_transaction).to be_a Appsignal::Transaction
-        expect(created_transaction.transaction_id).to eq "1"
-        expect(created_transaction.namespace).to eq "http_request"
+        it "assigns the transaction to current" do
+          expect(transaction).to eq current_transaction
+        end
       end
 
       context "when a transaction is already running" do
-        let(:running_transaction) { double(:transaction_id => 2) }
-        before { Thread.current[:appsignal_transaction] = running_transaction }
-
-        it "should not create a new transaction" do
-          expect(
-            Appsignal::Transaction.create("1", namespace, request, options)
-          ).to eq(running_transaction)
+        before { create_transaction }
+
+        it "does not create a new transaction, but returns the current transaction" do
+          expect do
+            new_transaction = create_transaction("2")
+            expect(new_transaction).to eq(current_transaction)
+            expect(new_transaction.transaction_id).to eq(transaction_id)
+          end.to_not change { current_transaction }
         end
 
-        it "should output a debug message" do
-          expect(Appsignal.logger).to receive(:debug)
-            .with("Trying to start new transaction 1 but 2 is already running. Using 2")
-
-          Appsignal::Transaction.create("1", namespace, request, options)
+        it "logs a debug message" do
+          create_transaction("2")
+          expect(log_contents(log)).to contains_log :debug,
+            "Trying to start new transaction with id '2', but a " \
+            "transaction with id '#{transaction_id}' is already " \
+            "running. Using transaction '#{transaction_id}'."
         end
 
-        context "with option to force a new transaction" do
-          let(:options) { { :force => true } }
-          it "should not create a new transaction" do
-            expect(
-              Appsignal::Transaction.create("1", namespace, request, options)
-            ).to_not eq(running_transaction)
+        context "with option :force => true" do
+          it "returns the newly created (and current) transaction" do
+            original_transaction = current_transaction
+            expect(original_transaction).to_not be_nil
+            expect(current_transaction.transaction_id).to eq transaction_id
+
+            options[:force] = true
+            expect(create_transaction("2")).to_not eq original_transaction
+            expect(current_transaction.transaction_id).to eq "2"
           end
         end
       end
     end
 
     describe ".current" do
-      before { Thread.current[:appsignal_transaction] = transaction }
-
       subject { Appsignal::Transaction.current }
 
-      context "if there is a transaction" do
-        before { Appsignal::Transaction.create("1", namespace, request, options) }
-
-        it "should return the correct transaction" do
-          is_expected.to eq transaction
+      context "when there is a current transaction" do
+        let!(:transaction) do
+          Appsignal::Transaction.create(transaction_id, namespace, request, options)
         end
 
-        it "should indicate it's not a nil transaction" do
-          expect(subject.nil_transaction?).to be_falsy
+        it "reads :appsignal_transaction from the current Thread" do
+          expect(subject).to eq Thread.current[:appsignal_transaction]
+          expect(subject).to eq transaction
         end
-      end
 
-      context "if there is no transaction" do
-        before do
-          Thread.current[:appsignal_transaction] = nil
+        it "is not a NilTransaction" do
+          expect(subject.nil_transaction?).to eq false
+          expect(subject).to be_a Appsignal::Transaction
         end
+      end
 
-        it "should return a nil transaction stub" do
-          is_expected.to be_a Appsignal::Transaction::NilTransaction
+      context "when there is no current transaction" do
+        it "has no :appsignal_transaction registered on the current Thread" do
+          expect(Thread.current[:appsignal_transaction]).to be_nil
         end
 
-        it "should indicate it's a nil transaction" do
-          expect(subject.nil_transaction?).to be_truthy
+        it "returns a NilTransaction stub" do
+          expect(subject.nil_transaction?).to eq true
+          expect(subject).to be_a Appsignal::Transaction::NilTransaction
         end
       end
     end
 
-    describe "complete_current!" do
-      before { Appsignal::Transaction.create("2", Appsignal::Transaction::HTTP_REQUEST, {}) }
+    describe ".complete_current!" do
+      let!(:transaction) { Appsignal::Transaction.create(transaction_id, namespace, options) }
 
-      it "should complete the current transaction and set the thread appsignal_transaction to nil" do
-        expect(Appsignal::Transaction.current).to receive(:complete)
+      it "completes the current transaction" do
+        expect(transaction).to eq current_transaction
+        expect(transaction).to receive(:complete).and_call_original
 
         Appsignal::Transaction.complete_current!
-
-        expect(Thread.current[:appsignal_transaction]).to be_nil
       end
 
-      it "should still clear the transaction if there is an error" do
-        expect(Appsignal::Transaction.current).to receive(:complete).and_raise "Error"
-
-        Appsignal::Transaction.complete_current!
-
-        expect(Thread.current[:appsignal_transaction]).to be_nil
+      it "unsets the current transaction on the current Thread" do
+        expect do
+          Appsignal::Transaction.complete_current!
+        end.to change { Thread.current[:appsignal_transaction] }.from(transaction).to(nil)
       end
 
-      context "if a transaction is discarded" do
-        it "should not complete the transaction" do
-          expect(Appsignal::Transaction.current.ext).to_not receive(:complete)
-
-          Appsignal::Transaction.current.discard!
-          expect(Appsignal::Transaction.current.discarded?).to be_truthy
+      context "when encountering an error while completing" do
+        before do
+          expect(transaction).to receive(:complete).and_raise VerySpecificError
+        end
 
+        it "logs an error message" do
           Appsignal::Transaction.complete_current!
-
-          expect(Thread.current[:appsignal_transaction]).to be_nil
+          expect(log_contents(log)).to contains_log :error,
+            "Failed to complete transaction ##{transaction.transaction_id}. VerySpecificError"
         end
 
-        it "should not be discarded when restore! is called" do
-          Appsignal::Transaction.current.discard!
-          expect(Appsignal::Transaction.current.discarded?).to be_truthy
-          Appsignal::Transaction.current.restore!
-          expect(Appsignal::Transaction.current.discarded?).to be_falsy
+        it "clears the current transaction" do
+          expect do
+            Appsignal::Transaction.complete_current!
+          end.to change { Thread.current[:appsignal_transaction] }.from(transaction).to(nil)
         end
       end
     end
   end
 
   describe "#complete" do
-    it "should sample data if it needs to be sampled" do
-      expect(transaction.ext).to receive(:finish).and_return(true)
-      expect(transaction).to receive(:sample_data)
-      expect(transaction.ext).to receive(:complete)
+    context "when transaction is being sampled" do
+      it "samples data" do
+        expect(transaction.ext).to receive(:finish).and_return(true)
+        # Stub call to extension, because that would remove the transaction
+        # from the extension.
+        expect(transaction.ext).to receive(:complete)
+
+        transaction.set_tags(:foo => "bar")
+        transaction.complete
+        expect(transaction.to_h["sample_data"]).to include(
+          "tags" => { "foo" => "bar" }
+        )
+      end
+    end
+
+    context "when transaction is not being sampled" do
+      it "does not sample data" do
+        expect(transaction).to_not receive(:sample_data)
+        expect(transaction.ext).to receive(:finish).and_return(false)
+        expect(transaction.ext).to receive(:complete).and_call_original
 
-      transaction.complete
+        transaction.complete
+      end
     end
 
-    it "should not sample data if it does not need to be sampled" do
-      expect(transaction.ext).to receive(:finish).and_return(false)
-      expect(transaction).to_not receive(:sample_data)
-      expect(transaction.ext).to receive(:complete)
+    context "when a transaction is marked as discarded" do
+      it "does not complete the transaction" do
+        expect(transaction.ext).to_not receive(:complete)
+
+        expect do
+          transaction.discard!
+        end.to change { transaction.discarded? }.from(false).to(true)
+
+        transaction.complete
+      end
+
+      it "logs a debug message" do
+        transaction.discard!
+        transaction.complete
+
+        expect(log_contents(log)).to contains_log :debug,
+          "Skipping transaction '#{transaction_id}' because it was manually discarded."
+      end
+
+      context "when a discarded transaction is restored" do
+        before { transaction.discard! }
+
+        it "completes the transaction" do
+          expect(transaction.ext).to receive(:complete).and_call_original
 
-      transaction.complete
+          expect do
+            transaction.restore!
+          end.to change { transaction.discarded? }.from(true).to(false)
+
+          transaction.complete
+        end
+      end
     end
   end
 
@@ -241,6 +302,37 @@ describe Appsignal::Transaction do
       end
     end
 
+    describe "#params" do
+      subject { transaction.params }
+
+      context "with custom params set on transaction" do
+        before do
+          transaction.params = { :foo => "bar" }
+        end
+
+        it "returns custom parameters" do
+          expect(subject).to eq(:foo => "bar")
+        end
+      end
+
+      context "without custom params set on transaction" do
+        it "returns parameters from request" do
+          expect(subject).to eq(
+            "action" => "show",
+            "controller" => "blog_posts",
+            "id" => "1"
+          )
+        end
+      end
+    end
+
+    describe "#params=" do
+      it "sets params on the transaction" do
+        transaction.params = { :foo => "bar" }
+        expect(transaction.params).to eq(:foo => "bar")
+      end
+    end
+
     describe "#set_tags" do
       it "should add tags to transaction" do
         expect do
@@ -733,19 +825,38 @@ describe Appsignal::Transaction do
     describe "#sanitized_params" do
       subject { transaction.send(:sanitized_params) }
 
-      context "without params" do
+      context "with custom params" do
+        before do
+          transaction.params = { :foo => "bar", :baz => :bat }
+        end
+
+        it "returns custom 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 "without request params" do
         before { allow(transaction.request).to receive(:params).and_return(nil) }
 
         it { is_expected.to be_nil }
       end
 
-      context "when params crashes" do
+      context "when request params crashes" do
         before { allow(transaction.request).to receive(:params).and_raise(NoMethodError) }
 
         it { is_expected.to be_nil }
       end
 
-      context "when params method does not exist" do
+      context "when request params method does not exist" do
         let(:options) { { :params_method => :nonsense } }
 
         it { is_expected.to be_nil }
@@ -982,6 +1093,34 @@ describe Appsignal::Transaction do
     end
   end
 
+  describe ".to_hash / .to_h" do
+    subject { transaction.to_hash }
+
+    context "when extension returns serialized JSON" do
+      it "parses the result and returns a Hash" do
+        expect(subject).to include(
+          "action" => nil,
+          "error" => nil,
+          "events" => [],
+          "id" => transaction_id,
+          "metadata" => {},
+          "namespace" => namespace,
+          "sample_data" => {}
+        )
+      end
+    end
+
+    context "when the extension returns invalid serialized JSON" do
+      before do
+        expect(transaction.ext).to receive(:to_json).and_return("foo")
+      end
+
+      it "raises a JSON parse error" do
+        expect { subject }.to raise_error(JSON::ParserError)
+      end
+    end
+  end
+
   describe Appsignal::Transaction::NilTransaction do
     subject { Appsignal::Transaction::NilTransaction.new }