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

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

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

data/lib/appsignal/integrations/dry_monitor.rb

@@ -4,24 +4,48 @@ module Appsignal
   module Integrations
     # @!visibility private
     module DryMonitorIntegration
+      # The event's formatter says what kind of work the event is, such as ROM
+      # reporting a SQL query as a dry-monitor `"sql"` event, and which library
+      # the instrumentation is for. Both are immutable once the span exists, so
+      # they have to be set here at event start.
+      #
+      # dry-monitor is a notification bus, so an event arriving over it is not
+      # necessarily dry-monitor's own work. A formatter that knows better says
+      # so; anything else is attributed to dry-monitor.
       def instrument(event_id, payload = {}, &block)
-        Appsignal::Transaction.current.start_event
-
-        super
-      ensure
         name = "#{event_id}.dry"
-        event_name, body, body_format = Appsignal::EventFormatter.format(name, payload)
+        # An event a dedicated integration already records is not recorded a
+        # second time here.
+        return super unless Appsignal::EventFormatter.record?(name)
+
+        begin
+          Appsignal::Transaction.current.start_event(
+            :opentelemetry_kind => Appsignal::EventFormatter.opentelemetry_kind(name),
+            :opentelemetry_scope =>
+              Appsignal::EventFormatter.opentelemetry_scope(name) ||
+                ["appsignal-ruby/dry_monitor", Appsignal::VERSION]
+          )
+
+          super
+        ensure
+          event_name, body, body_format = Appsignal::EventFormatter.format(name, payload)
+          # Set while the event's span is still open, so the attributes land
+          # on the event rather than on the transaction.
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::EventFormatter.opentelemetry_attributes(name, payload)
+          )
 
-        # dry-monitor reports an event under an id, such as `sql`, rather than
-        # a name. A formatter names the event it knows about, and an event
-        # without one is named after its id in the dry-monitor group. Either
-        # way the name has a group, which is what an event is listed under.
-        Appsignal::Transaction.current.finish_event(
-          event_name || name,
-          nil,
-          body,
-          body_format
-        )
+          # dry-monitor reports an event under an id, such as `sql`, rather than
+          # a name. A formatter names the event it knows about, and an event
+          # without one is named after its id in the dry-monitor group. Either
+          # way the name has a group, which is what an event is listed under.
+          Appsignal::Transaction.current.finish_event(
+            event_name || name,
+            nil,
+            body,
+            body_format
+          )
+        end
       end
     end
   end

data/lib/appsignal/integrations/excon/appsignal_middleware.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Integrations
+    # Excon middleware that writes trace context onto the outgoing request, so
+    # the called service joins this trace. The integration on the connection
+    # records the span; this middleware only injects.
+    #
+    # @!visibility private
+    class ExconMiddleware < ::Excon::Middleware::Base
+      def request_call(datum)
+        datum[:headers] ||= {}
+        # Inject from whatever span is current. The connection's client span is
+        # open around the whole request, so the written `traceparent` reflects
+        # the Excon client event. No-op outside collector mode.
+        Appsignal::OpenTelemetry.inject_context(datum[:headers])
+        super
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/excon.rb

@@ -4,16 +4,20 @@ module Appsignal
   module Integrations
     # @!visibility private
     module ExconIntegration
+      # The method of a request. Excon defaults it to GET further down, so the
+      # same default is applied here.
+      def self.method_for(datum)
+        datum[:method] || :get
+      end
+
       # The title of the event, built the way the Net::HTTP integration builds
       # its own: the request method and where the request went, without the
       # path, so paths stay out of event titles.
       #
       # Excon splits a request's data between the connection it is made on and
-      # the call that makes it, so both are read to build this. Excon defaults
-      # the method to GET itself, so the same default is applied here.
+      # the call that makes it, so both are read to build this.
       def self.title_for(datum)
-        method = (datum[:method] || :get).to_s.upcase
-        "#{method} #{datum[:scheme]}://#{datum[:host]}"
+        "#{method_for(datum).to_s.upcase} #{datum[:scheme]}://#{datum[:host]}"
       end
 
       def request(params = {})
@@ -38,18 +42,51 @@ module Appsignal
         # A pipelined request is the exception to this method being the whole of
         # a request. It returns before the response is read, so its event covers
         # only the sending.
-        title = ExconIntegration.title_for(data.merge(params))
+        datum = data.merge(params)
+
+        Appsignal.instrument(
+          "request.excon",
+          ExconIntegration.title_for(datum),
+          :opentelemetry_kind => :client,
+          :opentelemetry_scope => ["appsignal-ruby/excon", Appsignal::VERSION]
+        ) do
+          # Describes the span as an outgoing HTTP request. Together with the
+          # CLIENT kind, this is what the trace timeline reads to recognize it
+          # as one.
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::HttpClientRequest.attributes_for(
+              :method => ExconIntegration.method_for(datum),
+              :scheme => datum[:scheme],
+              :host => datum[:host],
+              :port => datum[:port],
+              :path => datum[:path]
+            )
+          )
+
+          response =
+            if Appsignal::Transaction.current?
+              # Excon retries a request, and follows a redirect, by calling this
+              # method again from inside the request it is retrying or
+              # following. Suppressing those means they count towards this event
+              # rather than becoming events of their own, so one request stays
+              # one event.
+              Appsignal::Transaction.current.suppress_http_client_events { super }
+            else
+              super
+            end
 
-        Appsignal.instrument("request.excon", title) do
-          if Appsignal::Transaction.current?
-            # Excon retries a request, and follows a redirect, by calling this
-            # method again from inside the request it is retrying or following.
-            # Suppressing those means they count towards this event rather than
-            # becoming events of their own, so one request stays one event.
-            Appsignal::Transaction.current.suppress_http_client_events { super }
-          else
-            super
-          end
+          # Describes the response on the same span as the request, which the
+          # semantic conventions ask for whenever one was received.
+          #
+          # A pipelined request returns the request data rather than a response,
+          # because its response has not been read yet, so there is no status to
+          # report for it.
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::HttpResponse.attributes_for(
+              response.respond_to?(:status) ? response.status : nil
+            )
+          )
+          response
         end
       end
     end

data/lib/appsignal/integrations/faraday.rb

@@ -2,10 +2,11 @@
 
 module Appsignal
   module Integrations
-    # Faraday middleware that records each request as a `request.faraday` event
-    # and suppresses the downstream HTTP client's own instrumentation, so the
-    # request is recorded once rather than as nested Faraday + Net::HTTP (or
-    # Excon) client events.
+    # Faraday middleware that records each request as a `request.faraday` client
+    # event, writes trace context onto the outgoing request so the called service
+    # joins this trace, and suppresses the downstream HTTP client's own
+    # instrumentation, so the request is recorded once rather than as nested
+    # Faraday + Net::HTTP (or Excon) client events.
     #
     # @!visibility private
     class FaradayMiddleware < ::Faraday::Middleware
@@ -16,17 +17,50 @@ module Appsignal
         # Net::HTTP's (scheme and host only), keeping paths out of event titles.
         Appsignal.instrument(
           "request.faraday",
-          "#{http_method} #{uri.scheme}://#{uri.host}"
+          "#{http_method} #{uri.scheme}://#{uri.host}",
+          :opentelemetry_kind => :client,
+          :opentelemetry_scope => ["appsignal-ruby/faraday", Appsignal::VERSION]
         ) do
+          # Describes the span as an outgoing HTTP request. Together with the
+          # CLIENT kind, this is what the trace timeline reads to recognize it
+          # as one.
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::HttpClientRequest.attributes_for(
+              :method => env[:method],
+              :scheme => uri.scheme,
+              :host => uri.host,
+              :port => uri.port,
+              :path => uri.path
+            )
+          )
+          # Write trace context onto the outgoing request so the called service
+          # joins this trace. Injected inside the instrument block, so the written
+          # `traceparent` reflects the Faraday client event's span. No-op outside
+          # collector mode. `env.request_headers` is the live outgoing header set
+          # and a valid carrier (it responds to `[]=`).
+          Appsignal::OpenTelemetry.inject_context(env.request_headers)
+
           # Faraday's default adapter is Net::HTTP, which AppSignal also
           # instruments. Suppress the adapter's own instrumentation so the
           # request appears once (as the Faraday event) rather than as nested
           # Faraday + Net::HTTP client events.
-          if Appsignal::Transaction.current?
-            Appsignal::Transaction.current.suppress_http_client_events { @app.call(env) }
-          else
-            @app.call(env)
-          end
+          response =
+            if Appsignal::Transaction.current?
+              Appsignal::Transaction.current.suppress_http_client_events { @app.call(env) }
+            else
+              @app.call(env)
+            end
+
+          # Describes the response on the same span, which the semantic
+          # conventions ask for whenever one was received. The event is still
+          # open here, so it lands on the request's own span. The status is read
+          # off the environment rather than the returned response, because an
+          # adapter fills the response in later than it fills in the environment.
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::HttpResponse.attributes_for(env[:status])
+          )
+
+          response
         end
       end
     end
@@ -37,8 +71,9 @@ module Appsignal
     # the build path is the only way to instrument every connection automatically.
     #
     # Just before the adapter (the innermost handler, where the request is sent)
-    # it inserts `FaradayMiddleware`, which records the `request.faraday` event
-    # and suppresses the downstream client. Skipped if it's already present.
+    # it inserts `FaradayMiddleware`, which records the `request.faraday` event,
+    # injects trace context, and suppresses the downstream client. Skipped if it's
+    # already present.
     #
     # @!visibility private
     module FaradayRackBuilderPatch

data/lib/appsignal/integrations/http.rb

@@ -9,7 +9,34 @@ module Appsignal
         parsed_request_uri = uri.is_a?(URI) ? uri : uri_module.parse(uri.to_s)
         request_uri = "#{parsed_request_uri.scheme}://#{parsed_request_uri.host}"
 
-        Appsignal.instrument("request.http_rb", "#{verb.upcase} #{request_uri}", &block)
+        Appsignal.instrument(
+          "request.http_rb",
+          "#{verb.to_s.upcase} #{request_uri}",
+          :opentelemetry_kind => :client,
+          :opentelemetry_scope => ["appsignal-ruby/http_rb", Appsignal::VERSION]
+        ) do
+          # Describes the span as an outgoing HTTP request. Together with the
+          # CLIENT kind, this is what the trace timeline reads to recognize it
+          # as one.
+          Appsignal::Transaction.current.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::HttpClientRequest.attributes_for(
+              :method => verb,
+              :scheme => parsed_request_uri.scheme,
+              :host => parsed_request_uri.host,
+              :port => parsed_request_uri.port,
+              :path => parsed_request_uri.path
+            )
+          )
+          # Describes the response on the same span, which the semantic
+          # conventions ask for whenever one was received. The event is still
+          # open here, so it lands on the request's own span. A request that
+          # followed redirects reports the status of the response it ended on.
+          block.call.tap do |response|
+            Appsignal::Transaction.current.add_opentelemetry_attributes(
+              Appsignal::OpenTelemetry::HttpResponse.attributes_for(response&.code)
+            )
+          end
+        end
       end
 
       # The event is recorded at the request boundary, so a redirected request
@@ -32,6 +59,21 @@ module Appsignal
           HttpIntegration.instrument(verb, uri) { super }
         end
       end
+
+      # Trace context has to ride on each outgoing hop's headers, so it's
+      # injected at `HTTP::Client#perform` -- the single send chokepoint in both
+      # http5 and http6, called once per request and once per redirect hop --
+      # where the live request headers are reachable. The event stays at the
+      # request boundary above, so a redirected request is still a single event;
+      # this only propagates context, and every hop carries it. No-op outside
+      # collector mode. `req.headers` is the live outgoing header set and a valid
+      # carrier (it responds to `[]=`).
+      module ContextInjection
+        def perform(req, options)
+          Appsignal::OpenTelemetry.inject_context(req.headers)
+          super
+        end
+      end
     end
   end
 end