appsignal 5.0.0.rc.1-java → 5.0.0.rc.2-java

data/lib/appsignal/helpers/instrumentation.rb

@@ -874,6 +874,10 @@ module Appsignal
       #   # The request headers will include:
       #   # { "PATH_INFO" => "/some-path", "HTTP_USER_AGENT" => "Firefox" }
       #
+      # @deprecated Use {#add_request_headers} for request headers and
+      #   {#add_request_environment} for the values a Rack environment holds
+      #   that are not request headers. This method takes both kinds at once,
+      #   so it has to work out which of them each value is.
       # @since 4.0.0
       # @param headers [Hash<String, Object>] The request headers to add to the transaction.
       # @yield This block is called when the transaction is sampled. The block's
@@ -881,6 +885,8 @@ module Appsignal
       # @yieldreturn [Hash<String, Object>]
       # @return [void]
       #
+      # @see #add_request_headers
+      # @see #add_request_environment
       # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
       #   Sample data guide
       # @see https://docs.appsignal.com/guides/filter-data/filter-headers.html
@@ -894,6 +900,88 @@ module Appsignal
       end
       alias set_headers add_headers
 
+      # Add request headers to the current transaction.
+      #
+      # Request headers are automatically added by most of our integrations. It
+      # should not be necessary to call this method unless you want to also
+      # report different request headers.
+      #
+      # Name each header the way OpenTelemetry names it, in lowercase and with
+      # dashes. In agent mode the names are converted to the Rack spellings the
+      # environment uses, so `accept` is reported as `HTTP_ACCEPT`.
+      #
+      # To filter request headers, see our request header filtering guide.
+      #
+      # When both the `headers` argument and a block is given to this method,
+      # the block is leading and the argument will _not_ be used.
+      #
+      # @example Add request headers
+      #   Appsignal.add_request_headers("accept" => "text/html")
+      #   # The request headers will include:
+      #   # { "accept" => "text/html" }
+      #
+      # @example Calling `add_request_headers` multiple times merges the values
+      #   Appsignal.add_request_headers("accept" => "text/html")
+      #   Appsignal.add_request_headers("user-agent" => "Firefox")
+      #   # The request headers will include:
+      #   # { "accept" => "text/html", "user-agent" => "Firefox" }
+      #
+      # @param headers [Hash<String, Object>] The request headers to add to the
+      #   transaction.
+      # @yield This block is called when the transaction is sampled. The block's
+      #   return value will become the new request headers.
+      # @yieldreturn [Hash<String, Object>]
+      # @return [void]
+      #
+      # @see #add_request_environment
+      # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
+      #   Sample data guide
+      # @see https://docs.appsignal.com/guides/filter-data/filter-headers.html
+      #   Request headers filtering guide
+      def add_request_headers(headers = nil, &block)
+        return unless Appsignal.active?
+        return unless Appsignal::Transaction.current?
+
+        transaction = Appsignal::Transaction.current
+        transaction.add_request_headers(headers, &block)
+      end
+
+      # Add values from the request environment to the current transaction.
+      #
+      # These are the values a Rack environment holds that are not request
+      # headers, such as `REMOTE_ADDR` and `QUERY_STRING`. Name each one the
+      # way Rack names it. Use {#add_request_headers} for the request headers.
+      #
+      # The request environment is automatically added by most of our
+      # integrations. It should not be necessary to call this method unless you
+      # want to also report different values.
+      #
+      # When both the `environment` argument and a block is given to this
+      # method, the block is leading and the argument will _not_ be used.
+      #
+      # @example Add request environment values
+      #   Appsignal.add_request_environment("REMOTE_ADDR" => "127.0.0.1")
+      #   # The request environment will include:
+      #   # { "REMOTE_ADDR" => "127.0.0.1" }
+      #
+      # @param environment [Hash<String, Object>] The request environment
+      #   values to add to the transaction.
+      # @yield This block is called when the transaction is sampled. The block's
+      #   return value will become the new request environment.
+      # @yieldreturn [Hash<String, Object>]
+      # @return [void]
+      #
+      # @see #add_request_headers
+      # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
+      #   Sample data guide
+      def add_request_environment(environment = nil, &block)
+        return unless Appsignal.active?
+        return unless Appsignal::Transaction.current?
+
+        transaction = Appsignal::Transaction.current
+        transaction.add_request_environment(environment, &block)
+      end
+
       # Add breadcrumbs to the transaction.
       #
       # Breadcrumbs can be used to trace what path a user has taken

data/lib/appsignal/hooks/action_cable.rb

@@ -57,7 +57,10 @@ module Appsignal
             transaction.set_metadata("path", request.path)
             transaction.set_metadata("method", "websocket")
             transaction.add_request_payload_if_nil { request.params }
-            transaction.add_headers_if_nil { request.env }
+            headers, environment =
+              Appsignal::Utils::RequestHeaders.split_lazily { request.env }
+            transaction.add_request_headers_if_nil(&headers)
+            transaction.add_request_environment_if_nil(&environment)
             transaction.add_session_data { request.session.to_h if request.respond_to? :session }
             transaction.add_tags(:request_id => request_id) if request_id
             Appsignal::Transaction.complete_current!
@@ -99,7 +102,10 @@ module Appsignal
             transaction.set_metadata("path", request.path)
             transaction.set_metadata("method", "websocket")
             transaction.add_request_payload_if_nil { request.params }
-            transaction.add_headers_if_nil { request.env }
+            headers, environment =
+              Appsignal::Utils::RequestHeaders.split_lazily { request.env }
+            transaction.add_request_headers_if_nil(&headers)
+            transaction.add_request_environment_if_nil(&environment)
             transaction.add_session_data { request.session.to_h if request.respond_to? :session }
             transaction.add_tags(:request_id => request_id) if request_id
             Appsignal::Transaction.complete_current!

data/lib/appsignal/hooks/active_job.rb

@@ -22,6 +22,14 @@ module Appsignal
         Appsignal::EventFormatter::RecordedElsewhere
       )
 
+      # Claimed for the same reason as the single enqueue above: this integration
+      # records the batch itself, as one producer event, and Active Job's own
+      # `enqueue_all.active_job` notification fires nested inside it.
+      Appsignal::EventFormatter.register(
+        "enqueue_all.active_job",
+        Appsignal::EventFormatter::RecordedElsewhere
+      )
+
       def self.version_7_1_or_higher?
         @version_7_1_or_higher ||=
           if dependencies_present?
@@ -37,6 +45,59 @@ module Appsignal
         defined?(::ActiveJob)
       end
 
+      # The parameters of the Active Job method this hook wraps to record a
+      # bulk enqueue. The wrapper reads the array of jobs out of the second
+      # one, so it is only safe to wrap a method that still takes these.
+      EXPECTED_INSTRUMENT_ENQUEUE_ALL_PARAMETERS = [
+        [:req, :queue_adapter],
+        [:req, :jobs]
+      ].freeze
+
+      # Whether Active Job records a bulk enqueue through a method at all. It
+      # only does so from version 7.1 on. Checking for the method, rather than
+      # for the version, keeps us from wrapping one on a version that has no
+      # bulk enqueue path to instrument.
+      def self.instrument_enqueue_all_defined?
+        ::ActiveJob.singleton_class.private_method_defined?(:instrument_enqueue_all)
+      end
+
+      # Whether that method still takes the arguments the wrapper reads.
+      #
+      # The method is private, so a later version of Active Job can change
+      # what it takes. Wrapping one that takes something else raises an
+      # ArgumentError inside every `ActiveJob.perform_all_later` call an
+      # application makes, which breaks enqueuing and not just its
+      # instrumentation. Refusing to wrap it is therefore the safe direction,
+      # whatever the refusal costs us.
+      def self.instrument_enqueue_all_parameters_match?
+        instrument_enqueue_all_parameters == EXPECTED_INSTRUMENT_ENQUEUE_ALL_PARAMETERS
+      end
+
+      # Active Job's own definition of the method, looked up past the wrapper
+      # this hook prepends. Installing twice would otherwise find that wrapper
+      # rather than the method it wraps, and so check it against itself. Only
+      # the wrapper is skipped, so a version of Active Job that defines the
+      # method somewhere else is still found.
+      def self.instrument_enqueue_all_method
+        method = ::ActiveJob.singleton_class.instance_method(:instrument_enqueue_all)
+        method = method.super_method while method&.owner == ActiveJobBulkEnqueueInstrumentation
+        method
+      end
+
+      def self.instrument_enqueue_all_parameters
+        instrument_enqueue_all_method&.parameters
+      end
+
+      # Names both sides of the mismatch, so a log line is enough to tell what
+      # Active Job changed and what the wrapper was written against.
+      def self.instrument_enqueue_all_mismatch_message
+        "Not instrumenting Active Job bulk enqueues: " \
+          "`ActiveJob.instrument_enqueue_all` takes " \
+          "#{instrument_enqueue_all_parameters.inspect} in this version of " \
+          "Active Job, where AppSignal expects " \
+          "#{EXPECTED_INSTRUMENT_ENQUEUE_ALL_PARAMETERS.inspect}."
+      end
+
       def dependencies_present?
         self.class.dependencies_present? && Appsignal.config &&
           Appsignal.config[:instrument_active_job]
@@ -52,6 +113,32 @@ module Appsignal
           ::ActiveJob::Base
             .prepend ::Appsignal::Hooks::ActiveJobHook::ActiveJobTraceContext
 
+          # Wrap the method Active Job records a bulk enqueue through, but only
+          # when it is still the method the wrapper knows how to read. When it
+          # is not, the batch goes unrecorded: the claim above stands, because
+          # a worse event is not worth reporting in place of the one we set out
+          # to report.
+          if !Appsignal::Hooks::ActiveJobHook.instrument_enqueue_all_defined?
+            # Nothing to instrument on a version with no bulk enqueue path, so
+            # there is nothing to report either.
+            Appsignal.internal_logger.debug(
+              "Not instrumenting Active Job bulk enqueues: this version of " \
+                "Active Job does not record them through " \
+                "`ActiveJob.instrument_enqueue_all`."
+            )
+          elsif !Appsignal::Hooks::ActiveJobHook.instrument_enqueue_all_parameters_match?
+            # A bulk enqueue path exists, but not one that can be wrapped
+            # without breaking `ActiveJob.perform_all_later` for the whole
+            # application. Report that at a level someone will see, because a
+            # batch that used to be recorded no longer is.
+            Appsignal.internal_logger.warn(
+              Appsignal::Hooks::ActiveJobHook.instrument_enqueue_all_mismatch_message
+            )
+          else
+            ::ActiveJob.singleton_class
+              .prepend ::Appsignal::Hooks::ActiveJobHook::ActiveJobBulkEnqueueInstrumentation
+          end
+
           next unless Appsignal::Hooks::ActiveJobHook.version_7_1_or_higher?
 
           # Only works on Active Job 7.1 and newer
@@ -63,6 +150,106 @@ module Appsignal
         end
       end
 
+      # Records an `enqueue_all.active_job` event when a batch of jobs is
+      # enqueued with `ActiveJob.perform_all_later`, so the batch shows up on the
+      # active transaction's timeline as one event, and as one producer span in
+      # collector mode.
+      #
+      # This wraps `instrument_enqueue_all` rather than `perform_all_later`, for
+      # two reasons. It is the method that records the batch, so it is called
+      # once for each queue adapter the batch spans, which is the same event
+      # count as the native notification it replaces. And it runs inside
+      # `perform_all_later`, after Active Job has split off the jobs it defers
+      # until the database transaction commits, so each of those halves is
+      # recorded when it is really enqueued.
+      #
+      # @!visibility private
+      module ActiveJobBulkEnqueueInstrumentation
+        private
+
+        def instrument_enqueue_all(_queue_adapter, jobs)
+          # When enqueue instrumentation is disabled, record nothing, the same as
+          # the single-job path.
+          return super if Appsignal.config && !Appsignal.config[:enable_job_enqueue_instrumentation]
+
+          # Another enqueue integration is already recording this enqueue, so
+          # don't record it a second time.
+          if Appsignal::Transaction.current? &&
+              Appsignal::Transaction.current.job_enqueue_events_suppressed?
+            return super
+          end
+
+          Appsignal.instrument(
+            "enqueue_all.active_job",
+            bulk_enqueue_title(jobs),
+            :opentelemetry_kind => :producer,
+            :opentelemetry_scope => ["appsignal-ruby/active_job", Appsignal::VERSION]
+          ) do
+            Appsignal::Transaction.current.add_opentelemetry_attributes(
+              Appsignal::OpenTelemetry::Messaging.enqueue_attributes(
+                "active_job",
+                :destination => bulk_enqueue_destination(jobs),
+                :batch_size => jobs.size
+              )
+            )
+            inject_context_into(jobs)
+            # A bulk enqueue does not go through `ActiveJob::Base#enqueue`, so
+            # nothing has suppressed the adapter (Sidekiq, Resque, ...) yet, and
+            # its own enqueue instrumentation would record an event for every job
+            # in the batch. Suppress it so the batch is recorded once, as this
+            # event.
+            if Appsignal::Transaction.current?
+              Appsignal::Transaction.current.suppress_job_enqueue_events { super }
+            else
+              super
+            end
+          end
+        end
+
+        # Writes this producer span's context onto every job in the batch, and
+        # marks each one as part of a batch, so the jobs that perform later link
+        # back to this span. A bulk enqueue never goes through
+        # `ActiveJob::Base#enqueue`, so the injection the single-job path does
+        # never runs for these jobs. The adapter serializes each job after this,
+        # and the `serialize` patch carries the headers to the wire from there.
+        # A no-op outside collector mode.
+        def inject_context_into(jobs)
+          jobs.each do |job|
+            headers = job.__otel_headers
+            Appsignal::OpenTelemetry.inject_context(headers)
+            Appsignal::OpenTelemetry.mark_active_job_batch(headers)
+          end
+        end
+
+        # The batch's job class, when every job in it has the same one. Active
+        # Job groups the jobs it enqueues by queue adapter rather than by class,
+        # so a batch can mix classes, and then there is no one class to name.
+        def bulk_enqueue_title(jobs)
+          job_class = shared_across(jobs) { |job| job.class.name }
+          return "bulk enqueue jobs" unless job_class
+
+          "bulk enqueue #{job_class} jobs"
+        end
+
+        # The queue the batch went to, when every job in it is on the same one.
+        # Grouping is by queue adapter and not by queue, so a batch can span
+        # queues, and then there is no one queue to name as the destination.
+        def bulk_enqueue_destination(jobs)
+          shared_across(jobs, &:queue_name)
+        end
+
+        # The one value every job in the batch shares, or nil when they differ
+        # or the batch is empty. Stops at the first job that disagrees, because
+        # a batch is as large as the caller made it and a single mismatch is
+        # enough to know.
+        def shared_across(jobs)
+          return if jobs.empty?
+
+          first = yield(jobs.first)
+          jobs.all? { |job| yield(job) == first } ? first : nil
+        end
+      end
+
       module ActiveJobClassInstrumentation
         def execute(job)
           enqueued_at = job["enqueued_at"]
@@ -96,7 +283,8 @@ module Appsignal
                 :opentelemetry_context => Appsignal::OpenTelemetry.extract_job_context(job),
                 :opentelemetry_scope => ["appsignal-ruby/active_job", Appsignal::VERSION],
                 :opentelemetry_kind => :consumer,
-                :opentelemetry_relationship => :both
+                :opentelemetry_relationship =>
+                  Appsignal::OpenTelemetry.active_job_relationship(job)
               )
             end
 

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -11,6 +11,18 @@ module Appsignal
           enqueue_with_instrumentation(job, block)
         end
 
+        # Delayed Job asks a job for its own maximum run time before it invokes
+        # it, and answering that question reads the job's payload. A job whose
+        # payload will not deserialize therefore raises inside the worker and
+        # never reaches `invoke_job`, so the callback below does not run and the
+        # failure goes unreported. This callback sits one step further out, on
+        # the worker's whole run of the job, which is where such a job can still
+        # be seen.
+        lifecycle.around(:perform) do |worker, job, &block|
+          report_job_that_cannot_be_loaded(job)
+          block.call(worker, job)
+        end
+
         lifecycle.around(:invoke_job) do |job, &block|
           invoke_with_instrumentation(job, block)
         end
@@ -75,18 +87,58 @@ module Appsignal
         job.name
       end
 
+      # Reports a job whose payload cannot be read, and does nothing at all for
+      # a job that loads. That is what keeps every ordinary job instrumented by
+      # the `:invoke_job` callback alone: no transaction is opened here, so an
+      # ordinary job's reported duration and its reported error are exactly
+      # what they were before this callback existed.
+      #
+      # Reading the payload here reads it a moment before the worker would have
+      # read it anyway. Delayed Job memoizes a payload that loads, so a job
+      # that is fine is deserialized once either way.
+      #
+      # Nothing is re-raised. The worker reads the same payload immediately
+      # after this returns, raises the same error, and fails the job as it
+      # always has. Raising here instead would move that error out of the
+      # worker's own handling and into the loop that reserves jobs.
+      def self.report_job_that_cannot_be_loaded(job)
+        job.payload_object
+        nil
+      rescue Exception => error
+        warn_unreadable_payload_once(error)
+
+        # No job data: the payload it would have been read from is the one that
+        # just failed to load.
+        transaction = create_perform_transaction(job, nil)
+        transaction.set_action_if_nil(action_name_without_payload(job))
+        transaction.set_error(error)
+        add_job_metadata(transaction, job)
+        Appsignal::Transaction.complete_current!
+      end
+
+      # The serialized Active Job job data inside a Delayed Job job, or nil when
+      # this is not an Active Job job. The Active Job adapter wraps the job data
+      # in an object that exposes it as `job_data`.
+      #
+      # Delayed Job has no carrier of its own, because a job's handler is a YAML
+      # dump of the object to run with nowhere to put a header, so an Active Job
+      # job is the only kind that arrives with a trace context at all.
+      #
+      # Reading it means deserializing the handler, which raises for a job whose
+      # class is gone, so a job that cannot be read gets no context. Delayed Job
+      # remembers a payload it read successfully, so doing this before the job
+      # runs costs no extra work later.
+      def self.active_job_data(job)
+        payload = job.payload_object
+        payload.job_data if payload.respond_to?(:job_data)
+      rescue => error
+        warn_unreadable_payload_once(error)
+        nil
+      end
+
       def self.invoke_with_instrumentation(job, block)
-        transaction =
-          Appsignal::Transaction.create(
-            Appsignal::Transaction::BACKGROUND_JOB,
-            :opentelemetry_scope => ["appsignal-ruby/delayed_job", Appsignal::VERSION],
-            :opentelemetry_kind => :consumer,
-            :opentelemetry_relationship => :both
-          )
-        transaction.add_opentelemetry_attributes(
-          Appsignal::OpenTelemetry::Messaging
-            .perform_attributes("delayed_job", :destination => queue_name(job))
-        )
+        job_data = active_job_data(job)
+        transaction = create_perform_transaction(job, job_data)
 
         begin
           Appsignal.instrument(
@@ -103,39 +155,127 @@ module Appsignal
           transaction.set_error(error)
           raise
         ensure
-          payload = job.payload_object
-          if payload.respond_to? :job_data
-            # ActiveJob
-            job_data = payload.job_data
-            transaction.set_action_if_nil("#{job_data["job_class"]}#perform")
-            transaction.add_function_parameters_if_nil(job_data.fetch("arguments", {}))
-          else
-            # Delayed Job
-            transaction.set_action_if_nil(action_name_from_payload(payload, job.name))
-            transaction.add_function_parameters_if_nil(extract_value(payload, :args, {}))
+          # Delayed Job raises when a job's handler will not deserialize, and it
+          # raises again on every further attempt to read it. Reading the payload
+          # here without a guard therefore replaces the error the job already
+          # failed with, and skips the rest of this block, so the transaction is
+          # never completed and the failure is never reported.
+          begin
+            payload = job.payload_object
+            if payload.respond_to? :job_data
+              # ActiveJob
+              job_data = payload.job_data
+              transaction.set_action_if_nil("#{job_data["job_class"]}#perform")
+              transaction.add_function_parameters_if_nil(job_data.fetch("arguments", {}))
+            else
+              # Delayed Job
+              transaction.set_action_if_nil(action_name_from_payload(payload, job.name))
+              transaction.add_function_parameters_if_nil(extract_value(payload, :args, {}))
+            end
+          rescue => error
+            warn_unreadable_payload_once(error)
+            transaction.set_action_if_nil(action_name_without_payload(job))
           end
 
-          transaction.add_tags(
-            :id => extract_value(job, :id, nil, true),
-            :queue => extract_value(job, :queue),
-            :priority => extract_value(job, :priority, 0),
-            :attempts => extract_value(job, :attempts, 0)
-          )
-
-          transaction.set_queue_start(extract_value(job, :run_at)&.to_i&.* 1_000)
+          add_job_metadata(transaction, job)
 
           Appsignal::Transaction.complete_current!
         end
       end
 
+      # The transaction a performed job is reported under. Shared by the two
+      # callbacks that can report a job, so both describe it the same way. The
+      # job data is passed in rather than read here, because the payload it
+      # would be read from is the one a job that cannot be loaded failed on.
+      def self.create_perform_transaction(job, job_data)
+        transaction = Appsignal::Transaction.create(
+          Appsignal::Transaction::BACKGROUND_JOB,
+          :opentelemetry_context =>
+            Appsignal::OpenTelemetry.extract_active_job_context(job_data),
+          :opentelemetry_scope => ["appsignal-ruby/delayed_job", Appsignal::VERSION],
+          :opentelemetry_kind => :consumer,
+          :opentelemetry_relationship =>
+            Appsignal::OpenTelemetry.active_job_relationship(job_data)
+        )
+        transaction.add_opentelemetry_attributes(
+          Appsignal::OpenTelemetry::Messaging
+            .perform_attributes("delayed_job", :destination => queue_name(job))
+        )
+        transaction
+      end
+
+      def self.add_job_metadata(transaction, job)
+        transaction.add_tags(
+          :id => extract_value(job, :id, nil, true),
+          :queue => extract_value(job, :queue),
+          :priority => extract_value(job, :priority, 0),
+          :attempts => extract_value(job, :attempts, 0)
+        )
+
+        transaction.set_queue_start(extract_value(job, :run_at)&.to_i&.* 1_000)
+      end
+
+      # The name Delayed Job derives from the raw handler when the payload will
+      # not deserialize. It reads the class name out of the handler with a
+      # regular expression, which covers the job class a deploy removed. That
+      # expression raises for a handler it does not match, and it is skipped
+      # altogether when the payload raised something Delayed Job does not wrap,
+      # so fall back to a name that says the failure came from inside Delayed
+      # Job. The failure is then reported under a name that can be found, and
+      # every job this happens to is grouped together.
+      def self.action_name_without_payload(job)
+        with_perform_suffix(job.name)
+      rescue
+        "DelayedJobInternal"
+      end
+
+      # Guards the check-and-set below, so two threads that read an unreadable
+      # payload at the same time cannot both warn. A constant so it is created
+      # once at load time, because creating it lazily would race in turn.
+      WARN_ONCE_LOCK = Mutex.new
+
+      # A deploy that removes a job class leaves every job of that class unable
+      # to deserialize, so this can be reached once per job. Each of those jobs
+      # reports its own error to AppSignal, so the log only has to say once that
+      # it is happening.
+      def self.warn_unreadable_payload_once(error)
+        should_warn = WARN_ONCE_LOCK.synchronize do
+          next false if @warned_unreadable_payload
+
+          @warned_unreadable_payload = true
+        end
+        return unless should_warn
+
+        Appsignal.internal_logger.warn(
+          "Unable to read a Delayed Job job's payload: #{error.class}: " \
+            "#{error.message}. Jobs whose payload cannot be read are reported " \
+            "without parameters. They are named after the class in their raw " \
+            "handler, or DelayedJobInternal when that cannot be read either."
+        )
+      end
+
+      # @!visibility private
+      #
+      # Resets the warn-once state. Only used to keep test runs isolated.
+      def self.reset_unreadable_payload_warning!
+        WARN_ONCE_LOCK.synchronize { @warned_unreadable_payload = false }
+      end
+
       def self.action_name_from_payload(payload, default_name)
         # Attempt to find appsignal_name override
         class_and_method_name = extract_value(payload, :appsignal_name, nil)
         return class_and_method_name if class_and_method_name.is_a?(String)
-        return default_name if default_name.split("#").length == 2
-        return default_name if default_name.split(".").length == 2
 
-        "#{default_name}#perform"
+        with_perform_suffix(default_name)
+      end
+
+      # An action name is a class and a method. A name that already names both,
+      # separated either way, is left alone.
+      def self.with_perform_suffix(name)
+        return name if name.split("#").length == 2
+        return name if name.split(".").length == 2
+
+        "#{name}#perform"
       end
 
       # rubocop:disable Style/OptionalBooleanParameter

data/lib/appsignal/integrations/que.rb

@@ -93,6 +93,35 @@ module Appsignal
         Array(tags).include?(BULK_TAG)
       end
 
+      # The class the Active Job adapter enqueues, with the serialized job data
+      # as its only argument. Que records the name in the job's `job_class`, and
+      # the name is fixed, because it is stored in every job record the adapter
+      # has ever written.
+      ACTIVE_JOB_WRAPPER = "ActiveJob::QueueAdapters::QueAdapter::JobWrapper"
+
+      # The trace context to continue: the Active Job layer when this is an
+      # Active Job job, the job's own tags otherwise. See `Appsignal::OpenTelemetry.extract_active_job_context`
+      # for why that layer wins.
+      # Que's tags are a carrier with a hard limit: five per job, shared with
+      # whatever the user puts there.
+      def extract_context(job_data, tags)
+        Appsignal::OpenTelemetry.extract_active_job_context(job_data) || extract(tags)
+      end
+
+      # The serialized Active Job job data inside a Que job, or nil when this is
+      # not an Active Job job.
+      #
+      # Que reads a job's arguments out of JSONB with symbol keys and only turns
+      # them back into strings on the way into Active Job, so they are
+      # stringified here too. Only the outer keys need it: the headers below them
+      # are an array of pairs of strings, which Que leaves alone.
+      def active_job_data(attrs)
+        return unless attrs[:job_class] == ACTIVE_JOB_WRAPPER
+
+        job_data = Array(attrs[:args]).first
+        job_data.transform_keys(&:to_s) if job_data.is_a?(Hash)
+      end
+
       def within_limits?(tags)
         tags.length <= MAX_TAGS_COUNT && tags.all? { |tag| tag.length <= MAX_TAG_LENGTH }
       end
@@ -104,21 +133,24 @@ module Appsignal
         local_attrs = respond_to?(:que_attrs) ? que_attrs : attrs
         tags = local_attrs.dig(:data, :tags)
 
-        # A job enqueued on its own is the only job its producer span produced, so
-        # it can be a child of that span as well as link to it. Every job in a
-        # batch shares one producer span, and a span can only have one parent, so
-        # parenting a batch would hang the whole batch off that single span. Only
-        # link those, which is what the OpenTelemetry messaging conventions ask
-        # for: they use links as the default, and allow the producer to be the
-        # parent only when it produced a single message.
-        relationship = QueTraceContext.bulk?(tags) ? :link : :both
+        job_data = QueTraceContext.active_job_data(local_attrs)
+        # A Que batch says so with a tag, and an Active Job batch says so in the
+        # job data, so both have to be asked. See
+        # `Appsignal::OpenTelemetry.active_job_relationship` for why a batch
+        # links back rather than parenting under the span that enqueued it.
+        relationship =
+          if QueTraceContext.bulk?(tags)
+            :link
+          else
+            Appsignal::OpenTelemetry.active_job_relationship(job_data)
+          end
 
         # Read the incoming trace context off the job's tags so the transaction
         # links back to the enqueuer. No-op outside collector mode.
         transaction =
           Appsignal::Transaction.create(
             Appsignal::Transaction::BACKGROUND_JOB,
-            :opentelemetry_context => QueTraceContext.extract(tags),
+            :opentelemetry_context => QueTraceContext.extract_context(job_data, tags),
             :opentelemetry_scope => ["appsignal-ruby/que", Appsignal::VERSION],
             :opentelemetry_kind => :consumer,
             :opentelemetry_relationship => relationship