appsignal 4.10.3-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?
@@ -21,59 +37,6 @@ 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]
@@ -83,34 +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
-
-          # 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: Rails' own notification stays
-          # suppressed, 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
+            .prepend ::Appsignal::Hooks::ActiveJobHook::ActiveJobTraceContext
 
           next unless Appsignal::Hooks::ActiveJobHook.version_7_1_or_higher?
 
@@ -123,103 +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
-
-      # 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.
-      #
-      # 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)
-          # Skip recording the event when enqueue events are suppressed, which is
-          # also the case when enqueue instrumentation is disabled. Same check as
-          # the single-job path above.
-          if Appsignal::Transaction.current? &&
-              Appsignal::Transaction.current.job_enqueue_events_suppressed?
-            return super
-          end
-
-          Appsignal.instrument("enqueue_all.active_job", bulk_enqueue_title(jobs)) do
-            # 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
-
-        # 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 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"]
@@ -241,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)
@@ -302,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,29 +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` and `enqueue_all.active_job`.
-        # It records its own event for a single enqueue, and one event for a
-        # whole batch, with Rails' native notification nested inside. The
-        # Faraday integration owns `request.faraday`.
-        SUPPRESSED_EVENT_NAMES = [
-          "enqueue.active_job",
-          "enqueue_all.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,
@@ -37,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