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

data/lib/appsignal/helpers/metrics.rb

@@ -16,14 +16,7 @@ module Appsignal
       # @see https://docs.appsignal.com/metrics/custom.html
       #   Metrics documentation
       def set_gauge(name, value, tags = {})
-        Appsignal::Extension.set_gauge(
-          name.to_s,
-          value.to_f,
-          Appsignal::Utils::Data.generate(tags)
-        )
-      rescue RangeError
-        Appsignal.internal_logger
-          .warn("The gauge value '#{value}' for metric '#{name}' is too big")
+        Appsignal::Backends.metrics.set_gauge(name, value, tags)
       end
 
       # Report a counter metric.
@@ -39,14 +32,7 @@ module Appsignal
       # @see https://docs.appsignal.com/metrics/custom.html
       #   Metrics documentation
       def increment_counter(name, value = 1.0, tags = {})
-        Appsignal::Extension.increment_counter(
-          name.to_s,
-          value.to_f,
-          Appsignal::Utils::Data.generate(tags)
-        )
-      rescue RangeError
-        Appsignal.internal_logger
-          .warn("The counter value '#{value}' for metric '#{name}' is too big")
+        Appsignal::Backends.metrics.increment_counter(name, value, tags)
       end
 
       # Report a distribution metric.
@@ -62,14 +48,7 @@ module Appsignal
       # @see https://docs.appsignal.com/metrics/custom.html
       #   Metrics documentation
       def add_distribution_value(name, value, tags = {})
-        Appsignal::Extension.add_distribution_value(
-          name.to_s,
-          value.to_f,
-          Appsignal::Utils::Data.generate(tags)
-        )
-      rescue RangeError
-        Appsignal.internal_logger
-          .warn("The distribution value '#{value}' for metric '#{name}' is too big")
+        Appsignal::Backends.metrics.add_distribution_value(name, value, tags)
       end
     end
   end

data/lib/appsignal/hooks/action_cable.rb

@@ -37,10 +37,16 @@ module Appsignal
           env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||= request_id
 
           transaction =
-            Appsignal::Transaction.create(Appsignal::Transaction::ACTION_CABLE)
+            Appsignal::Transaction.create(
+              Appsignal::Transaction::ACTION_CABLE,
+              :opentelemetry_scope => ["appsignal-ruby/action_cable", Appsignal::VERSION]
+            )
 
           begin
-            Appsignal.instrument "subscribed.action_cable" do
+            Appsignal.instrument(
+              "subscribed.action_cable",
+              :opentelemetry_scope => ["appsignal-ruby/action_cable", Appsignal::VERSION]
+            ) do
               inner.call
             end
           rescue Exception => exception
@@ -50,7 +56,7 @@ module Appsignal
             transaction.set_action_if_nil("#{channel.class}#subscribed")
             transaction.set_metadata("path", request.path)
             transaction.set_metadata("method", "websocket")
-            transaction.add_params_if_nil { request.params }
+            transaction.add_request_payload_if_nil { request.params }
             transaction.add_headers_if_nil { request.env }
             transaction.add_session_data { request.session.to_h if request.respond_to? :session }
             transaction.add_tags(:request_id => request_id) if request_id
@@ -73,10 +79,16 @@ module Appsignal
           env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||= request_id
 
           transaction =
-            Appsignal::Transaction.create(Appsignal::Transaction::ACTION_CABLE)
+            Appsignal::Transaction.create(
+              Appsignal::Transaction::ACTION_CABLE,
+              :opentelemetry_scope => ["appsignal-ruby/action_cable", Appsignal::VERSION]
+            )
 
           begin
-            Appsignal.instrument "unsubscribed.action_cable" do
+            Appsignal.instrument(
+              "unsubscribed.action_cable",
+              :opentelemetry_scope => ["appsignal-ruby/action_cable", Appsignal::VERSION]
+            ) do
               inner.call
             end
           rescue Exception => exception
@@ -86,7 +98,7 @@ module Appsignal
             transaction.set_action_if_nil("#{channel.class}#unsubscribed")
             transaction.set_metadata("path", request.path)
             transaction.set_metadata("method", "websocket")
-            transaction.add_params_if_nil { request.params }
+            transaction.add_request_payload_if_nil { request.params }
             transaction.add_headers_if_nil { request.env }
             transaction.add_session_data { request.session.to_h if request.respond_to? :session }
             transaction.add_tags(:request_id => request_id) if request_id

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