Refactor Active Job enqueues

Record the enqueue.active_job event from a prepend on
ActiveJob::Base#enqueue instead of Rails' native enqueue.active_job
notification, which the notifications path now suppresses so the
enqueue is recorded once.

This gives AppSignal a single enqueue event it owns, matching the
other job integrations. Behaviour is otherwise unchanged: the event
still records only when a transaction is active at enqueue time.

Author: unflxw

.changesets/instrument-active-job-enqueues.md

@@ -0,0 +1,10 @@
+---
+bump: patch
+type: change
+---
+
+Record the `enqueue.active_job` event from AppSignal's own Active Job
+instrumentation rather than from Rails' native `enqueue.active_job`
+notification, which is now suppressed so the enqueue is recorded once. The
+event still shows up on the active transaction when enqueuing from within a web
+request or another job; there is no change to what you see.

lib/appsignal/hooks/active_job.rb

@@ -29,6 +29,8 @@ def install
         ActiveSupport.on_load(:active_job) do
           ::ActiveJob::Base
             .extend ::Appsignal::Hooks::ActiveJobHook::ActiveJobClassInstrumentation
+          ::ActiveJob::Base
+            .prepend ::Appsignal::Hooks::ActiveJobHook::ActiveJobEnqueueInstrumentation
 
           next unless Appsignal::Hooks::ActiveJobHook.version_7_1_or_higher?
 
@@ -41,6 +43,23 @@ def install
         end
       end
 
+      # Records an `enqueue.active_job` event when a job is enqueued, so the
+      # enqueue shows up on the active transaction's timeline (e.g. when
+      # enqueuing from within a web request or another job).
+      #
+      # Wrapping `enqueue` ourselves -- rather than relying on Rails' native
+      # `enqueue.active_job` notification, which the AppSignal notifications
+      # path now suppresses -- gives us a single event we own. Like all
+      # AppSignal events, this only records when there's an active transaction;
+      # an enqueue with no transaction is a transparent pass-through.
+      #
+      # @!visibility private
+      module ActiveJobEnqueueInstrumentation
+        def enqueue(*)
+          Appsignal.instrument("enqueue.active_job") { super }
+        end
+      end
+
       module ActiveJobClassInstrumentation
         def execute(job) # rubocop:disable Metrics/CyclomaticComplexity
           enqueued_at = job["enqueued_at"]

lib/appsignal/integrations/active_support_notifications.rb

@@ -7,16 +7,20 @@ module ActiveSupportNotificationsIntegration
       class << self
         BANG = "!"
 
+        # Events a dedicated AppSignal integration already records, so the
+        # generic notifications path must not record them a second time. The
+        # ActiveJob hook owns `enqueue.active_job`: it wraps the enqueue in its
+        # own event, and Rails' native notification fires nested inside it.
+        SUPPRESSED_EVENT_NAMES = ["enqueue.active_job"].freeze
+
         def start_event(name)
-          # Events that start with a bang are internal to Rails
-          instrument_this = name[0] != BANG
-          Appsignal::Transaction.current.start_event if instrument_this
+          return unless record_event?(name)
+
+          Appsignal::Transaction.current.start_event
         end
 
         def finish_event(name, payload = {})
-          # Events that start with a bang are internal to Rails
-          instrument_this = name[0] != BANG
-          return unless instrument_this
+          return unless record_event?(name)
 
           title, body, body_format = Appsignal::EventFormatter.format(name, payload)
           Appsignal::Transaction.current.finish_event(
@@ -26,6 +30,13 @@ def finish_event(name, payload = {})
             body_format
           )
         end
+
+        # Events starting with a bang are internal to Rails; suppressed events
+        # are recorded by a dedicated integration instead. Both `start_event`
+        # and `finish_event` gate on this so the event stack stays balanced.
+        def record_event?(name)
+          name[0] != BANG && !SUPPRESSED_EVENT_NAMES.include?(name.to_s)
+        end
       end
 
       module InstrumentIntegration

spec/lib/appsignal/hooks/activejob_spec.rb

@@ -333,6 +333,34 @@ def perform(*_args)
       end
     end
 
+    context "when enqueuing a job" do
+      before { ActiveJob::Base.queue_adapter = :test }
+
+      context "with an active transaction" do
+        it "records a single enqueue.active_job event on the transaction" do
+          transaction = http_request_transaction
+          set_current_transaction(transaction)
+
+          ActiveJobTestJob.perform_later
+
+          # Exactly one enqueue event: ours. Rails' native `enqueue.active_job`
+          # notification is suppressed so it isn't recorded a second time.
+          event_names = transaction.to_h["events"].map { |event| event["name"] }
+          expect(event_names.count("enqueue.active_job")).to eq(1)
+        end
+      end
+
+      context "without an active transaction" do
+        it "is a transparent pass-through that still enqueues the job" do
+          expect do
+            ActiveJobTestJob.perform_later
+          end.to_not(change { created_transactions.count })
+
+          expect(ActiveJob::Base.queue_adapter.enqueued_jobs.count).to eq(1)
+        end
+      end
+    end
+
     context "with params" do
       let(:options) { { :filter_parameters => ["foo"] } }