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

data/lib/appsignal/hooks/active_job.rb

@@ -6,6 +6,22 @@ module Appsignal
     class ActiveJobHook < Appsignal::Hooks::Hook
       register :active_job
 
+      # This integration records the enqueue itself, as a producer event that
+      # also injects trace context, and Active Job's own `enqueue.active_job`
+      # notification fires nested inside it. Claim the event so that the
+      # generic notification paths leave it alone.
+      #
+      # Claimed here, when this file is required, rather than in `install`.
+      # `install` only runs when Active Job instrumentation is turned on, but
+      # a customer who turns it off does not want to see the native
+      # notification reported instead. This call does not touch any
+      # `ActiveJob` constant, so it is safe to run even when the library is
+      # not present.
+      Appsignal::EventFormatter.register(
+        "enqueue.active_job",
+        Appsignal::EventFormatter::RecordedElsewhere
+      )
+
       def self.version_7_1_or_higher?
         @version_7_1_or_higher ||=
           if dependencies_present?
@@ -30,8 +46,11 @@ module Appsignal
         ActiveSupport.on_load(:active_job) do
           ::ActiveJob::Base
             .extend ::Appsignal::Hooks::ActiveJobHook::ActiveJobClassInstrumentation
+          # Carry W3C trace context across the enqueue/perform boundary in
+          # collector mode (no-ops otherwise). The patches are cheap and
+          # mode-gated inside their method bodies, so install them unconditionally.
           ::ActiveJob::Base
-            .prepend ::Appsignal::Hooks::ActiveJobHook::ActiveJobEnqueueInstrumentation
+            .prepend ::Appsignal::Hooks::ActiveJobHook::ActiveJobTraceContext
 
           next unless Appsignal::Hooks::ActiveJobHook.version_7_1_or_higher?
 
@@ -44,42 +63,6 @@ module Appsignal
         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(*, **)
-          # Skip recording the event when enqueue events are suppressed. That is
-          # the case when enqueue instrumentation is disabled, and it keeps this
-          # integration consistent with the standalone adapters (Sidekiq, ...),
-          # which already gate their own enqueue event on this check.
-          if Appsignal::Transaction.current? &&
-              Appsignal::Transaction.current.job_enqueue_events_suppressed?
-            return super
-          end
-
-          Appsignal.instrument("enqueue.active_job", "enqueue #{self.class.name} job") do
-            # Active Job enqueues through an adapter (Sidekiq, Resque, ...) that
-            # has its own enqueue instrumentation. Suppress it so the enqueue is
-            # recorded once, as this event, rather than as nested Active Job +
-            # adapter events.
-            if Appsignal::Transaction.current?
-              Appsignal::Transaction.current.suppress_job_enqueue_events { super }
-            else
-              super
-            end
-          end
-        end
-      end
-
       module ActiveJobClassInstrumentation
         def execute(job)
           enqueued_at = job["enqueued_at"]
@@ -101,12 +84,39 @@ module Appsignal
               # We don't have a separate integration for this QueueAdapter like
               # we do for Sidekiq.
               #
+              # Read the trace context off the job so the transaction links back
+              # to the enqueuer (no-op outside collector mode). Only here, in the
+              # standalone branch: when a wrapper integration (e.g. Sidekiq)
+              # created the transaction, it already extracted, so we must not
+              # extract a second time.
+              #
               # Prefer job_id from provider, instead of ActiveJob's internal ID.
-              Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
+              Appsignal::Transaction.create(
+                Appsignal::Transaction::BACKGROUND_JOB,
+                :opentelemetry_context => Appsignal::OpenTelemetry.extract_job_context(job),
+                :opentelemetry_scope => ["appsignal-ruby/active_job", Appsignal::VERSION],
+                :opentelemetry_kind => :consumer,
+                :opentelemetry_relationship => :both
+              )
             end
 
+          unless has_wrapper_transaction
+            # Describes this span as a job being performed. The messaging
+            # system is what the trace timeline reads to recognize background
+            # job work, and `active_job` is the value OpenTelemetry's own Active
+            # Job instrumentation uses.
+            #
+            # Only set when this hook created the transaction. When an adapter
+            # integration created it, that adapter already named itself, and its
+            # answer is the more specific one.
+            transaction.add_opentelemetry_attributes(
+              Appsignal::OpenTelemetry::Messaging
+                .perform_attributes("active_job", :destination => job["queue_name"])
+            )
+          end
+
           begin
-            transaction.add_params_if_nil(job["arguments"])
+            transaction.add_function_parameters_if_nil(job["arguments"])
 
             transaction_tags = ActiveJobHelpers.transaction_tags_for(job)
             transaction.add_tags(transaction_tags)
@@ -162,6 +172,85 @@ module Appsignal
         end
       end
 
+      # Reads and writes W3C trace context on the ActiveJob enqueue/perform
+      # boundary, wire-compatible with OpenTelemetry's ActiveJob instrumentation.
+      # All of this no-ops outside collector mode.
+      #
+      # Context rides on the job under `__otel_headers`, the same carrier OTel
+      # uses. Stock `serialize`/`deserialize` only carry a fixed key set, so --
+      # like OTel -- we patch both plus an accessor to round-trip it. The on-wire
+      # value is run through ActiveJob's argument serializer (an array of
+      # `[key, value]` pairs), matching OTel byte-for-byte so an AppSignal- and an
+      # OTel-instrumented service read each other's jobs.
+      module ActiveJobTraceContext
+        # Inject on enqueue from inside a producer event, so the job carries this
+        # transaction's context and the perform later links back. Mirrors the
+        # Sidekiq client middleware: an AppSignal event (a producer span in
+        # collector mode), not a direct SDK span. `Appsignal.instrument` is a
+        # transparent pass-through when there's no active transaction, and
+        # `inject_context` no-ops outside collector mode.
+        def enqueue(*, **)
+          # When enqueue instrumentation is disabled, drop the trace context
+          # along with the event. Without an enqueue event there is no producer
+          # span, so the context we would write is that of whatever span is
+          # current, such as the surrounding web request. The job that performs
+          # later would then link back to a span that is not a producer.
+          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.active_job",
+            "enqueue #{self.class.name} job",
+            :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 => queue_name)
+            )
+            Appsignal::OpenTelemetry.inject_context(__otel_headers)
+            # Active Job enqueues through an adapter (Sidekiq, Resque, ...) that
+            # has its own enqueue instrumentation. Suppress it so the enqueue is
+            # recorded once, as this event, rather than as nested Active Job +
+            # adapter events.
+            if Appsignal::Transaction.current?
+              Appsignal::Transaction.current.suppress_job_enqueue_events { super }
+            else
+              super
+            end
+          end
+        end
+
+        def serialize
+          super.tap do |data|
+            Appsignal::OpenTelemetry.if_started do
+              next if __otel_headers.empty?
+
+              data["__otel_headers"] = ::ActiveJob::Arguments.serialize(__otel_headers)
+            end
+          end
+        end
+
+        def deserialize(job_data)
+          super
+          serialized = job_data["__otel_headers"]
+          @__otel_headers =
+            serialized ? ::ActiveJob::Arguments.deserialize(serialized).to_h : {}
+        end
+
+        def __otel_headers
+          @__otel_headers ||= {}
+        end
+
+        attr_writer :__otel_headers
+      end
+
       module ActiveJobHelpers
         ACTION_MAILER_CLASSES = [
           "ActionMailer::DeliveryJob",

data/lib/appsignal/hooks/at_exit.rb

@@ -38,7 +38,10 @@ module Appsignal
 
           report_error = true
 
-          Appsignal.report_error(error) do |transaction|
+          Appsignal.report_error(
+            error,
+            :opentelemetry_scope => ["appsignal-ruby/at_exit", Appsignal::VERSION]
+          ) do |transaction|
             transaction.set_namespace("unhandled")
           end
         ensure

data/lib/appsignal/hooks/excon.rb

@@ -12,15 +12,35 @@ module Appsignal
 
       def install
         require "appsignal/integrations/excon"
+        require "appsignal/integrations/excon/appsignal_middleware"
         # Instrument the request at the connection, rather than by registering
         # AppSignal as Excon's instrumentor. An instrumentor is told about a
         # request in pieces, none of which covers the wait for the response, and
         # there is only room for one of them, so registering ours would replace
         # any the application set up itself.
         ::Excon::Connection.prepend Appsignal::Integrations::ExconIntegration
+        install_middleware
 
         Appsignal::Environment.report_enabled("excon")
       end
+
+      private
+
+      # Trace context is written onto the outgoing request by a middleware,
+      # because that is where Excon exposes the request's headers.
+      #
+      # Insert it just before the Mock middleware, the innermost one, where the
+      # response is produced. That way it runs before the request is sent.
+      # Appending to the end would place it after Mock, which short-circuits the
+      # chain before reaching it.
+      def install_middleware
+        middlewares = ::Excon.defaults[:middlewares].dup
+        return if middlewares.include?(Appsignal::Integrations::ExconMiddleware)
+
+        index = middlewares.index(::Excon::Middleware::Mock) || middlewares.length
+        middlewares.insert(index, Appsignal::Integrations::ExconMiddleware)
+        ::Excon.defaults[:middlewares] = middlewares
+      end
     end
   end
 end

data/lib/appsignal/hooks/faraday.rb

@@ -6,6 +6,22 @@ module Appsignal
     class FaradayHook < Appsignal::Hooks::Hook
       register :faraday
 
+      # This integration records the request itself, so Faraday's own
+      # instrumentation middleware would report the same work again as a
+      # `request.faraday` notification. Claim it so the generic notification
+      # paths leave it alone.
+      #
+      # Claimed here, when this file is required, rather than in `install`.
+      # `install` only runs when Faraday instrumentation is turned on, but a
+      # customer who turns it off does not want to see the native
+      # notification reported instead. This call does not touch any
+      # `Faraday` constant, so it is safe to run even when the library is not
+      # present.
+      Appsignal::EventFormatter.register(
+        "request.faraday",
+        Appsignal::EventFormatter::RecordedElsewhere
+      )
+
       def dependencies_present?
         defined?(::Faraday) && Appsignal.config && Appsignal.config[:instrument_faraday]
       end

data/lib/appsignal/hooks/http.rb

@@ -32,6 +32,11 @@ module Appsignal
         if defined?(HTTP::Session)
           HTTP::Session.prepend Appsignal::Integrations::HttpIntegration::KeywordOptions
         end
+        # Propagate trace context onto every outgoing hop (redirects included) at
+        # `Client#perform`, where the live request headers are reachable. Kept
+        # separate from the request-boundary event above: it only injects context
+        # and no-ops outside collector mode.
+        HTTP::Client.prepend Appsignal::Integrations::HttpIntegration::ContextInjection
 
         Appsignal::Environment.report_enabled("http_rb")
       end

data/lib/appsignal/hooks/resque.rb

@@ -15,7 +15,7 @@ module Appsignal
         Resque::Job.prepend Appsignal::Integrations::ResqueIntegration
 
         # Resque enqueues through the `Resque.push` singleton method, so prepend
-        # onto its singleton class to record the enqueue event.
+        # onto its singleton class to write the trace context onto outgoing jobs.
         Resque.singleton_class.prepend Appsignal::Integrations::ResquePushIntegration
       end
     end

data/lib/appsignal/hooks/sequel.rb

@@ -10,8 +10,13 @@ module Appsignal
           "sql.sequel",
           nil,
           sql,
-          Appsignal::EventFormatter::SQL_BODY_FORMAT
+          Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          :opentelemetry_kind => :client,
+          :opentelemetry_scope => ["appsignal-ruby/sequel", Appsignal::VERSION]
         ) do
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::Hooks::SequelHook.sequel_db_attributes(self)
+          )
           super
         end
       end
@@ -25,8 +30,13 @@ module Appsignal
           "sql.sequel",
           nil,
           sql,
-          Appsignal::EventFormatter::SQL_BODY_FORMAT
+          Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          :opentelemetry_kind => :client,
+          :opentelemetry_scope => ["appsignal-ruby/sequel", Appsignal::VERSION]
         ) do
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::Hooks::SequelHook.sequel_db_attributes(self)
+          )
           super
         end
       end
@@ -35,6 +45,26 @@ module Appsignal
     class SequelHook < Appsignal::Hooks::Hook
       register :sequel
 
+      # The query's `Sequel::Database` names both the engine it talks to and
+      # the database it is connected to, neither of which the sql.sequel
+      # formatter can see -- it only gets the query text. Shared by both
+      # extensions above, whichever one a given Sequel version registers.
+      #
+      # @!visibility private
+      def self.sequel_db_attributes(database)
+        attributes = {}
+
+        name = Appsignal::OpenTelemetry::SqlDbSystem.name_for_sequel(database.database_type)
+        attributes["db.system.name"] = name if name
+
+        # `opts[:database]` is Sequel's own option key for the database to
+        # connect to, so it doubles as the database's name.
+        namespace = database.opts[:database].to_s
+        attributes["db.namespace"] = namespace unless namespace.empty?
+
+        attributes
+      end
+
       def dependencies_present?
         defined?(::Sequel::Database) &&
           Appsignal.config &&

data/lib/appsignal/hooks/shoryuken.rb

@@ -19,9 +19,9 @@ module Appsignal
           end
 
           # Servers enqueue jobs too, so they need the client middleware that
-          # records the enqueue event. Shoryuken only yields `configure_client`
-          # outside the server, so register it here as well for enqueues from
-          # within a worker.
+          # writes the trace context onto outgoing messages. Shoryuken only
+          # yields `configure_client` outside the server, so register it here as
+          # well for enqueues from within a worker.
           config.client_middleware do |chain|
             chain.add Appsignal::Integrations::ShoryukenClientMiddleware
           end

data/lib/appsignal/hooks/sidekiq.rb

@@ -45,7 +45,7 @@ module Appsignal
           end
 
           # Servers enqueue jobs too, so they need the client middleware that
-          # records the enqueue event.
+          # writes the trace context onto outgoing jobs.
           config.client_middleware do |chain|
             chain.add Appsignal::Integrations::SidekiqClientMiddleware
           end

data/lib/appsignal/integrations/action_cable.rb

@@ -11,7 +11,10 @@ module Appsignal
         request_id = request.request_id || SecureRandom.uuid
         env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||= request_id
 
-        transaction = Appsignal::Transaction.create(Appsignal::Transaction::ACTION_CABLE)
+        transaction = Appsignal::Transaction.create(
+          Appsignal::Transaction::ACTION_CABLE,
+          :opentelemetry_scope => ["appsignal-ruby/action_cable", Appsignal::VERSION]
+        )
 
         begin
           super
@@ -20,7 +23,7 @@ module Appsignal
           raise exception
         ensure
           transaction.set_action_if_nil("#{self.class}##{args.first["action"]}")
-          transaction.add_params_if_nil(args.first)
+          transaction.add_request_payload_if_nil(args.first)
           transaction.add_session_data { request.session.to_h if request.respond_to? :session }
           transaction.set_metadata("path", request.path)
           transaction.set_metadata("method", "websocket")

data/lib/appsignal/integrations/active_support_notifications.rb

@@ -7,24 +7,52 @@ module Appsignal
       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, with Rails' native notification nested inside), and the
-        # Faraday integration owns `request.faraday`.
-        SUPPRESSED_EVENT_NAMES = ["enqueue.active_job", "request.faraday"].freeze
-
         def start_event(name)
           return unless record_event?(name)
 
-          Appsignal::Transaction.current.start_event
+          # The event's formatter says what kind of work the event is, such as
+          # a SQL query being an outgoing call to a database, and can name the
+          # library the instrumentation is for. Both are immutable once the
+          # span exists, so they have to be set here at event start.
+          #
+          # A formatter that names no library leaves the scope to be derived
+          # from the event name, which is right for everything Rails reports.
+          Appsignal::Transaction.current.start_event(
+            :opentelemetry_kind => Appsignal::EventFormatter.opentelemetry_kind(name),
+            :opentelemetry_scope =>
+              Appsignal::EventFormatter.opentelemetry_scope(name) || scope_for(name)
+          )
+        end
+
+        # ActiveSupport::Notifications bridges many Rails components through this
+        # one path (`sql.active_record`, `render_template.action_view`, ...), so
+        # derive the instrumentation scope from the event name's group: the part
+        # after the last dot. That gives each Rails component its own scope
+        # (`appsignal-ruby/active_record`, `appsignal-ruby/action_view`, ...)
+        # rather than lumping them under one. A name without a group falls back
+        # to the default scope in the backend.
+        def scope_for(name)
+          # Only names with a group (a dot) map to a component scope. A name
+          # without one has no component to attribute it to, so it falls back to
+          # the default scope in the backend (returning nil here).
+          parts = name.to_s.split(".")
+          return if parts.length < 2 || parts.last.empty?
+
+          ["appsignal-ruby/#{parts.last}", Appsignal::VERSION]
         end
 
         def finish_event(name, payload = {})
           return unless record_event?(name)
 
           title, body, body_format = Appsignal::EventFormatter.format(name, payload)
-          Appsignal::Transaction.current.finish_event(
+          transaction = Appsignal::Transaction.current
+          # Set while the event's span is still open, so the attributes land on
+          # the event rather than on the transaction.
+          transaction.add_opentelemetry_attributes(
+            Appsignal::EventFormatter.opentelemetry_attributes(name, payload)
+          )
+          record_error_type(transaction, payload)
+          transaction.finish_event(
             name.to_s,
             title,
             body,
@@ -32,12 +60,29 @@ module Appsignal
           )
         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.
+        # Says what kind of failure ended the event, which the OpenTelemetry
+        # semantic conventions ask for on a span whose operation failed.
+        #
+        # ActiveSupport puts the exception in the payload when the instrumented
+        # block raised, and it does so before it hands control to any of the
+        # paths this integration hooks into. So the failure is readable here and
+        # there is nothing to rescue, whether the event was reported through a
+        # block or through a `start` and `finish` pair.
+        def record_error_type(transaction, payload)
+          error = payload[:exception_object]
+          return unless error
+
+          transaction.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::ErrorType.attributes_for(error.class.name)
+          )
+        end
+
+        # Events starting with a bang are internal to Rails. An event that the
+        # registry says a dedicated integration records is not recorded again
+        # here. Both `start_event` and `finish_event` gate on this so the event
+        # stack stays balanced.
         def record_event?(name)
-          name = name.to_s
-          name[0] != BANG && !SUPPRESSED_EVENT_NAMES.include?(name)
+          name.to_s[0] != BANG && Appsignal::EventFormatter.record?(name)
         end
       end
 

data/lib/appsignal/integrations/data_mapper.rb

@@ -12,22 +12,34 @@ module Appsignal
       ].freeze
 
       def log(message)
+        attributes = {}
+
         # If scheme is SQL-like, try to sanitize it, otherwise clear the body
         if SQL_CLASSES.include?(self.class.to_s)
           body_content = message.query
           body_format = Appsignal::EventFormatter::SQL_BODY_FORMAT
+          # The connection class names the engine it talks to, one of the four
+          # SQL_CLASSES above; a class this map does not recognise leaves the
+          # SQL sentinel to apply, same as it would for a fifth SQL_CLASSES
+          # entry this map has not been taught about.
+          db_system = Appsignal::OpenTelemetry::SqlDbSystem.name_for_data_mapper(self.class.to_s)
+          attributes["db.system.name"] = db_system if db_system
         else
           body_content = ""
           body_format = Appsignal::EventFormatter::DEFAULT
         end
 
-        # Record event
+        # Record event. The query is an outgoing call to the database, so tag it
+        # as a client span (collector mode); no-op in agent mode.
         Appsignal::Transaction.current.record_event(
           "query.data_mapper",
           "DataMapper Query",
           body_content,
           message.duration,
-          body_format
+          body_format,
+          :opentelemetry_kind => :client,
+          :opentelemetry_scope => ["appsignal-ruby/data_mapper", Appsignal::VERSION],
+          :opentelemetry_attributes => attributes
         )
         super
       end

data/lib/appsignal/integrations/delayed_job_plugin.rb

@@ -25,6 +25,11 @@ module Appsignal
       # another job). An enqueue with no active transaction is a transparent
       # pass-through.
       def self.enqueue_with_instrumentation(job, block)
+        # Skip the enqueue event when enqueue instrumentation is disabled.
+        if Appsignal.config && !Appsignal.config[:enable_job_enqueue_instrumentation]
+          return block.call(job)
+        end
+
         # Under Active Job the enqueue is already recorded as an
         # `enqueue.active_job` event, so skip recording it again here.
         if Appsignal::Transaction.current? &&
@@ -32,7 +37,20 @@ module Appsignal
           return block.call(job)
         end
 
-        Appsignal.instrument("enqueue.delayed_job", "enqueue #{enqueue_name(job)} job") do
+        Appsignal.instrument(
+          "enqueue.delayed_job",
+          "enqueue #{enqueue_name(job)} job",
+          :opentelemetry_kind => :producer,
+          :opentelemetry_scope => ["appsignal-ruby/delayed_job", Appsignal::VERSION]
+        ) do
+          # Describes this span as a job being enqueued. The messaging system
+          # is what the trace timeline reads to recognize background job work,
+          # and `delayed_job` is the value OpenTelemetry's own Delayed Job
+          # instrumentation uses.
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::Messaging
+              .enqueue_attributes("delayed_job", :destination => queue_name(job))
+          )
           block.call(job)
         end
       end
@@ -43,6 +61,12 @@ module Appsignal
       # `enqueue Class#method job` rather than the bare `enqueue Class job`. We
       # accept that inconsistency so the enqueue and perform events stay tied to
       # the same name for the rare job that sets it.
+      # The queue a job is on. Not every Delayed Job backend has queues, so a
+      # job that does not know its queue is described without one.
+      def self.queue_name(job)
+        job.queue if job.respond_to?(:queue)
+      end
+
       def self.enqueue_name(job)
         payload = job.payload_object
         appsignal_name = extract_value(payload, :appsignal_name, nil)
@@ -53,10 +77,26 @@ module Appsignal
 
       def self.invoke_with_instrumentation(job, block)
         transaction =
-          Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
+          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))
+        )
 
         begin
-          Appsignal.instrument("perform_job.delayed_job") do
+          Appsignal.instrument(
+            "perform_job.delayed_job",
+            :opentelemetry_scope => ["appsignal-ruby/delayed_job", Appsignal::VERSION]
+          ) do
+            Appsignal::Transaction.current.add_opentelemetry_attributes(
+              Appsignal::OpenTelemetry::Messaging
+                .perform_attributes("delayed_job", :destination => queue_name(job))
+            )
             block.call(job)
           end
         rescue Exception => error
@@ -68,11 +108,11 @@ module Appsignal
             # ActiveJob
             job_data = payload.job_data
             transaction.set_action_if_nil("#{job_data["job_class"]}#perform")
-            transaction.add_params_if_nil(job_data.fetch("arguments", {}))
+            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_params_if_nil(extract_value(payload, :args, {}))
+            transaction.add_function_parameters_if_nil(extract_value(payload, :args, {}))
           end
 
           transaction.add_tags(