Add after_create transaction hook

Add a hook that allows for blocks of arbitrary code to be applied to
modify a transaction after it has been created.

Author: unflxw

lib/appsignal/transaction.rb

@@ -44,6 +44,19 @@ def create(namespace)
         end
       end
 
+      # @api private
+      # @return [Array<Proc>]
+      # Add a block, if given, to be executed after a transaction is created.
+      # The block will be called with the transaction as an argument.
+      # Returns the array of blocks that will be executed.
+      def after_create(&block)
+        @after_create ||= Set.new
+
+        return @after_create if block.nil?
+
+        @after_create << block
+      end
+
       # @api private
       def set_current_transaction(transaction)
         Thread.current[:appsignal_transaction] = transaction
@@ -137,6 +150,8 @@ def initialize(namespace, id: SecureRandom.uuid, ext: nil)
         @namespace,
         0
       ) || Appsignal::Extension::MockTransaction.new
+
+      run_after_create_hooks
     end
 
     # @api private
@@ -596,6 +611,12 @@ def to_h
 
     attr_reader :breadcrumbs
 
+    def run_after_create_hooks
+      self.class.after_create.each do |block|
+        block.call(self)
+      end
+    end
+
     def _set_error(error)
       backtrace = cleaned_backtrace(error.backtrace)
       @ext.set_error(

spec/lib/appsignal/transaction_spec.rb

@@ -2145,6 +2145,78 @@ def to_s
     end
   end
 
+  describe "#after_create" do
+    it "stores the given hook when passed as a block" do
+      transaction = new_transaction
+
+      expect(Appsignal::Transaction.after_create).to be_empty
+      Appsignal::Transaction.after_create do |t|
+        t.set_action("hook_action")
+      end
+
+      expect(Appsignal::Transaction.after_create).to_not be_empty
+
+      expect(transaction).to_not have_action("hook_action")
+      Appsignal::Transaction.after_create.first.call(transaction)
+      expect(transaction).to have_action("hook_action")
+    end
+
+    it "stores the given hook when using <<" do
+      expect(Appsignal::Transaction.after_create).to be_empty
+      proc = proc do |transaction|
+        transaction.set_action("hook_action")
+      end
+
+      Appsignal::Transaction.after_create << proc
+
+      expect(Appsignal::Transaction.after_create).to eq(Set.new([proc]))
+    end
+
+    it "only stores a hook once when added several times" do
+      expect(Appsignal::Transaction.after_create).to be_empty
+      proc = proc do |transaction|
+        transaction.set_action("hook_action")
+      end
+
+      Appsignal::Transaction.after_create(&proc)
+      Appsignal::Transaction.after_create << proc
+
+      expect(Appsignal::Transaction.after_create).to eq(Set.new([proc]))
+    end
+
+    it "calls the given hook when a transaction is created" do
+      block = proc do |transaction|
+        transaction.set_action("hook_action")
+      end
+
+      Appsignal::Transaction.after_create(&block)
+
+      expect(block).to(
+        receive(:call)
+          .with(kind_of(Appsignal::Transaction))
+          .and_call_original
+      )
+
+      expect(new_transaction).to have_action("hook_action")
+    end
+
+    it "calls all the hooks in order" do
+      Appsignal::Transaction.after_create do |transaction|
+        transaction.set_namespace("hook_namespace_1")
+        transaction.set_action("hook_action_1")
+      end
+
+      Appsignal::Transaction.after_create do |transaction|
+        transaction.set_action("hook_action_2")
+      end
+
+      transaction = new_transaction
+
+      expect(transaction).to have_namespace("hook_namespace_1")
+      expect(transaction).to have_action("hook_action_2")
+    end
+  end
+
   describe "#start_event" do
     let(:transaction) { new_transaction }
 

spec/spec_helper.rb

@@ -100,6 +100,7 @@ def spec_system_tmp_dir
     Appsignal::Testing.clear!
     Appsignal::Loaders.clear!
     Appsignal::CheckIn.clear!
+    Appsignal::Transaction.after_create.clear
 
     clear_current_transaction!
     stop_minutely_probes