Title the Que enqueue events with the job

The `enqueue.que` event now carries an "enqueue <Class> job" title, and
`bulk_enqueue.que` a "bulk enqueue <Class> jobs" title, so the timeline
shows which job was enqueued.

The class is resolved the way Que resolves it: an explicit `:job_class`,
else the class the enqueue was called on. For a bulk enqueue called on
`Que::Job` itself the class isn't known up front, so the title is left
class-less.

Author: unflxw

lib/appsignal/integrations/que.rb

@@ -43,7 +43,7 @@ def _run(*args)
     # from within a web request or another job); otherwise it's a transparent
     # pass-through.
     module QueClientPlugin
-      def enqueue(*_args, **_rest)
+      def enqueue(*_args, job_options: {}, **_rest)
         # Inside a Que 2 `bulk_enqueue` block the batch is recorded once by the
         # `bulk_enqueue` wrapper, so each inner enqueue is a pass-through to
         # avoid recording an event per job.
@@ -54,7 +54,10 @@ def enqueue(*_args, **_rest)
         return super if Appsignal::Transaction.current? &&
           Appsignal::Transaction.current.job_enqueue_events_suppressed?
 
-        Appsignal.instrument("enqueue.que") { super }
+        # Resolve the job class the way Que does: an explicit `:job_class`, else
+        # the class `enqueue` was called on.
+        title = "enqueue #{job_options[:job_class] || name} job"
+        Appsignal.instrument("enqueue.que", title) { super }
       end
 
       private
@@ -71,13 +74,27 @@ def bulk_insert_in_progress?
     # `bulk_enqueue` on Que versions that have none. The whole batch records a
     # single `bulk_enqueue.que` event; the inner enqueues are pass-throughs.
     module QueBulkClientPlugin
-      def bulk_enqueue(*_args, **_rest)
+      def bulk_enqueue(*_args, job_options: {}, **_rest)
         # Under Active Job the enqueue is already recorded as an
         # `enqueue.active_job` event, so skip recording it again here.
         return super if Appsignal::Transaction.current? &&
           Appsignal::Transaction.current.job_enqueue_events_suppressed?
 
-        Appsignal.instrument("bulk_enqueue.que") { super }
+        Appsignal.instrument("bulk_enqueue.que", bulk_enqueue_title(job_options)) { super }
+      end
+
+      private
+
+      # The batch's job class is known up front only from an explicit
+      # `:job_class` or when `bulk_enqueue` is called on a concrete subclass;
+      # called on `Que::Job` itself the class isn't known until the inner
+      # enqueues run, so the title is left class-less.
+      def bulk_enqueue_title(job_options)
+        job_class = job_options[:job_class]
+        job_class ||= name unless equal?(::Que::Job)
+        return "bulk enqueue jobs" unless job_class
+
+        "bulk enqueue #{job_class} jobs"
       end
     end
   end

spec/lib/appsignal/integrations/que_spec.rb

@@ -225,8 +225,10 @@ def enqueue(tags: ["user:42"])
 
         enqueue
 
-        event_names = transaction.to_h["events"].map { |event| event["name"] }
-        expect(event_names).to include("enqueue.que")
+        # Records an enqueue event on the transaction, titled after the job.
+        event = transaction.to_h["events"].find { |e| e["name"] == "enqueue.que" }
+        expect(event).to_not be_nil
+        expect(event["title"]).to eq("enqueue MyQueJob job")
         expect(enqueued_tags).to eq(["user:42"])
       end
     end
@@ -280,9 +282,13 @@ def bulk_enqueue(tags: ["user:42"])
 
         bulk_enqueue
 
+        # One event for the whole batch, titled after the job -- the inner
+        # enqueues don't add their own.
+        bulk_events =
+          transaction.to_h["events"].select { |e| e["name"] == "bulk_enqueue.que" }
+        expect(bulk_events.size).to eq(1)
+        expect(bulk_events.first["title"]).to eq("bulk enqueue MyQueJob jobs")
         event_names = transaction.to_h["events"].map { |event| event["name"] }
-        # One event for the whole batch -- the inner enqueues don't add their own.
-        expect(event_names.count { |name| name == "bulk_enqueue.que" }).to eq(1)
         expect(event_names).to_not include("enqueue.que")
         expect(enqueued_tags).to eq(["user:42"])
       end