appsignal 4.10.4-java → 5.0.0-java

data/lib/appsignal/hooks/active_job.rb

@@ -6,6 +6,30 @@ 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
+      )
+
+      # 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?
@@ -83,14 +107,17 @@ 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
 
           # 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.
+          # 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.
@@ -123,45 +150,10 @@ 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.
+      # 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
@@ -176,15 +168,31 @@ module Appsignal
         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.
+          # 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)) do
+          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
@@ -198,6 +206,21 @@ module Appsignal
           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.
@@ -208,6 +231,13 @@ module Appsignal
           "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
@@ -241,12 +271,40 @@ 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 =>
+                  Appsignal::OpenTelemetry.active_job_relationship(job)
+              )
             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 +360,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
 

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